GSL-GNU (Scientific Library)

GSL (GNU Scientific Library) is a library written in C for scientific computing. Below are some related packages

Desired=Unknown/Install/Remove/Purge/Hold| Status=Not/Inst/Cfg-files/Unpacked/Failed-cfg/Half-inst/trig-aWait/Trig-pend|/ Err?=(none)/Hold/Reinst-required/X=both-problems (Status,Err: uppercase=bad)||/ Name                                 Version                    Description+++-====================================-==========================-============================================un  gsl                                                       (no description available)ii  gsl-bin                              1.11-2                     GNU Scientific Library (GSL) -- binary packaii  gsl-doc-pdf                          1.11-2                     GNU Scientific Library (GSL) Reference Manuaun  gsl-ref-html                                              (no description available)un  gsl-ref-pdf                                               (no description available)pn  gsl-ref-psdoc                                             (no description available)un  libgsl0                                                   (no description available)ii  libgsl0ldbl                          1.11-2                     GNU Scientific Library (GSL) -- library pack

Among them, libgsl0ldbl is the real Library:

/usr/lib/libgsl.so.0.12.0/usr/lib/libgslcblas.so.0.0.0/usr/share/doc/libgsl0ldbl/changelog.Debian.gz/usr/share/doc/libgsl0ldbl/changelog.gz/usr/share/doc/libgsl0ldbl/THANKS.gz/usr/share/doc/libgsl0ldbl/BUGS.gz/usr/share/doc/libgsl0ldbl/README/usr/share/doc/libgsl0ldbl/AUTHORS/usr/share/doc/libgsl0ldbl/SUPPORT/usr/share/doc/libgsl0ldbl/TODO.gz/usr/share/doc/libgsl0ldbl/copyright/usr/share/doc/libgsl0ldbl/NEWS.gz/usr/share/lintian/overrides/libgsl0ldbl/usr/lib/libgsl.so.0/usr/lib/libgslcblas.so.0

There is also a related GSL-bin, which mainly contains two programs,

/usr/share/man/man1/gsl-histogram.1.gz/usr/share/man/man1/gsl-randist.1.gz/usr/share/doc/usr/share/doc/gsl-bin/usr/share/doc/gsl-bin/changelog.Debian.gz/usr/share/doc/gsl-bin/changelog.gz/usr/share/doc/gsl-bin/copyright/usr/bin/usr/bin/gsl-randist/usr/bin/gsl-histogram

GSL-randist and GSL-histogram are programs that generate random samples and calculate histograms respectively.

The following describes how to use GSL program interfaces and routines Based on GSL-doc-PDF. The header files used by GSL programs are generally placed in the/usr/include/GSL/directory (libgsl0-dev). c programs usually use # include to read the pre-processing program CPP into the corresponding function, macro description, you can use-lgsl-lgslcblas to connect to the corresponding database during connection. It is usually possible to connect to-LM. To use some inline functions, you can open the have_inline macro. Note that since long double is related to the platform, it is generally not recommended.

The naming rules in GSL generally use GSL as the prefix (without namespace or sigh). The function is generally gsl_foo_fn (corresponding to double) and the rest are gsl_foo_type_fn, generally, the type is gsl_foo or gsl_foo_type (no template, sigh again ). The header file is generally gsl_foo.h (containing all types) or gsl_foo_type.h.

The error handling in GSL follows the POSIX thread library, returns 0 normally, returns a non-zero error, and sets the error value according to gsl_errno.h. You can use gsl_strerror to express the returned value in a string. By default, the error handler provided by GSL prints an error and calls abort. This is a gsl_error_handler_t function, which can be set through the gsl_set_error_handler () function.

Mathematical functions common mathematical functions gsl_math.h
Including common mathematical constants (M _ *), gsl_posinf, gsl_neginf, gsl_nan, and the corresponding judgment functions gsl_isnan (), gsl_isinf (), and gsl_finite (). In addition, some methods for Fast Calculation of function values are provided. gsl_log1p () calculates log (1 + x), gsl_exp1m () calculates ex-1, gsl_hypot (), and gsl_hypot3 calculate Euclidean space norms, gsl_aco SH (), gsl_asinh (), and gsl_atanh () are anti-Hyperbolic functions, gsl_ldexp (X,
Y) Calculate X. 2y, gsl_frexp () Calculate the base part of X in binary scientific notation. Calculate the power gsl_pow_int or gsl_pow_n (n = 2,..., 9 ). Test symbols: gsl_sign, parity: gsl_is_even and gsl_is_odd. Take the size gsl_max and gsl_min. The gsl_fcmp function is recommended for floating point size.

Complex Numbers plural gsl_complex.h, gsl_complex_math.h
To define a complex number, you can use gsl_complex_rect or gsl_complex_polar. In addition, you can obtain the real and virtual gsl_real and gsl_imag, and set gsl_set_complex, gsl_set_real, and gsl_set_imag. The following parameters are available: gsl_complex_arg (), gsl_complex_abs (), gsl_complex_abs2, and gsl_complex_logabs (). The addition, subtraction, multiplication, and division of plural numbers are gsl_complex_op (), where op can be ADD, sub, MUL
Similar to Div, gsl_complex_op_real () has the same operation as the real number. It has the following operations: Scalar (), gsl_complex_conjugate (), inverse gsl_complex_inverse (), and inverse gsl_complex_negative. For example, calculate the square root gsl_complex_sqrt (add _ real to the real number), power gsl_complex_pow (the number of times is real plus _ real), index gsl_complex_exp, logarithm gsl_complex_log (loh10
Or log_ B ). There are also trigonometric functions, inverse trigonometric functions, hyperbolic functions, and inverse hyperbolic functions.

Polynomial polynomial gsl_poly.h
Generally, the polynomial coefficient can be given. To obtain the polynomial function value by calling the Horner method from the lower order to the higher order using an array, gsl_poly_eval () can be used. For the complex number, gsl_poly_complex_eval () is used (), the polynomial of the coefficient is gsl_complex_poly_complex_eval (). Another expression is expressed by the Newton difference method. In this case, the difference node is input to create a polynomial, gsl_poly_dd_init (), and the function value can be obtained by using gsl_poly_dd_eval (), you can also convert this type of polynomial into the form of Taylor expansion gsl_poly_dd_taylor (). It can be used to solve the root of quadratic polynomials.
Gsl_poly_solve_quadratic (). You can use gsl_poly_complex_solve_quadratic () for the root feature (). Replace quadratic with cubic for cubic equation. There is no analytical solution for polynomials higher than four times, and matrix feature values are often used for approximation. gsl provides a solution. First, gsl_poly_complex_workspace_alloc () is used to allocate the storage root space, and then gsl_poly_complex_solve () is called () after solving the problem, use gsl_poly_complex_workspace_free ()
Release.

Special Functions special functions: gsl_sf.h, gsl_sf _ *. h
There are two calling methods. One is similar to a normal function, gsl_sf_function (), and the other is gsl_sf_function_e. Gsl_sf_result.h provides a structure for error estimation. Generally, the function has three modes to control the calculation accuracy: gsl_prec_double, gsl_prec_single, and gsl_prec_approx. The provided special functions include Airy (see gsl_sf_airy.h) function value, zero point, derivative zero point, Bessel function (see gsl_sf_bessel.h) function value, zero point, and Classen
Functions (see metrics), Coulomb functions (see metrics), coupling coefficients (see gsl_sf_coupling.h), Dawson functions (see gsl_sf_dawson.h), and Debye functions (see gsl_sf_debye.h ), dilogorithm function (see gsl_sf_dilog.h), multiplication error function (see cosine), elliptic integral (see gsl_sf_ellint.h), and the Gini elliptic function (see gsl_sf_elljac.h ).
Gsl_sf_erf.h, GNU libc has similar functions), exponential functions (see gsl_sf_exp.h), exponential points (see gsl_sf_expint.h), and Fermi-Dirac functions (see examples ), gamma and beta functions (see gsl_sf_gamma.h), gegenbauer functions (see dimensions), hypergeometric functions (see gsl_sf_hyperg.h), Laguerre functions (see gsl_sf_laguerre.h), and Lambert W functions (see
Gsl_sf_lambert.h), legendh function and Spherical Harmonic Function (see gsl_sf_legendre.h), logarithm and related function (see gsl_sf_log.h), Mathieu function (see gauge), power function (see gauge), PSI) functions (see gsl_sf_psi.h), synchrotron functions (see gsl_sf_synchrotron.h), transport functions (see gsl_sf_transport.h), triangular hyperbolic functions (see gsl_sf_trig.h ),
Function (see gsl_sf_zeta.h ).

Vectors and matrices vector and matrix gsl_block.h, gsl_vector.h, gsl_matrix.h
The creation of a vector or matrix depends on the gsl_block structure. You can use gsl_block_alloc () and gsl_block_calloc () for allocation, gsl_block_free () for release, and streaming input and output, such as gsl_block_fread (), gsl_block_fwrite (), gsl_block_fprintf (), and gsl_block_fscanf (). Both vector and matrix contain a gsl_block pointer, and the operation is similar to the block. Such as vector
Similar operations include callback (), gsl_vector_calloc (), callback (), gsl_vector_fwrite (), callback (), and callback (). You can also use gsl_vector_get () and gsl_vector_set () obtain/set the value of a certain component. gsl_vector_ptr () and gsl_vector_const_ptr () obtain the address of one component. In addition, some functions facilitate the initial vector, such
Gsl_vector_set_all (), gsl_vector_set_zero (), and gsl_vector_set_basis (). To access a subset of a vector element, you can use a vector view object, which can be generated using some functions (with the corresponding const version ), it is better to use it only in the stack (that is, directly operate the object itself, rather than the pointer), such as gsl_vector_subvector () to generate a continuous subset. gsl_vector_subvector_with_stride () generates a subset with a fixed interval, gsl_vector_complex_real ()
And gsl_vector_complex_imag () generate a real or image view. gsl_vector_view_array () generates a vector view for an array, and gsl_vector_view_array_with_stride () generates a vector view with a fixed interval. The replication or interchange between vectors includes gsl_vector_memcpy () and gsl_vector_swap (). Swap gsl_vector_swap_elements () between vector elements, reverse order
Gsl_vector_reverse (). The four arithmetic operations between vectors: gsl_vector_op (), number multiplication (OP = scale), and constant (OP = add_constant ). Maximum and minimum values of a vector (OP = max, Min, MINMAX) or corresponding indexes (OP = max_index, min_index, and minmax_index ). Determine whether a vector is 0 vector (OP = isnull), positive (ispos), negative (isneg), and non-negative (isnonneg ). Matrix and vector are slightly different in that they are indexed by two subscripts.
Replace vector with matrix. You can also create a view, gsl_matrix _ (sub) Row/column (), or an angle element gsl_matrix _ (sub, super) diagonal () for the rows or columns of the matrix (). You can use gsl_matrix_get/set_row/COL () to read/write a row/column of a matrix to a vector (). The gsl_matrix_swap_rows/columns () or the columns exchange gsl_matrix_swap_rowcol (), transpose or transpose to copy gsl_matrix_transpose () and forward (). Matrix operation in progress
Mul_elements and div_elements are for elements.

Permutations replace gsl_permutation.h
This is the basic data structure that generates replacement. Generally, gsl_permutation _ (c) alloc () is used to allocate memory, and gsl_permutation_init () is initialized as the replacement metadata. You can use gsl_permutation_memcpy () for replication, gsl_permutation_free () is released. You can use gsl_permutation_get () to access the replacement element, and use gsl_permutation_swap () to interchangeably (). In addition, you can use gsl_permutation_size () to obtain the replacement size, gsl_permutation_data ()
Get the pointer pointing to the replacement, and gsl_permutation_valid () verifies whether it is a valid permutation. There are also some replacement operations, such as gsl_permutation_reverse () reversal, gsl_permutation_inverse () inverse, calculate the next/previous one with gsl_permutation_next/Prev () according to the Lexicographic Order (). Apply permutation to the array. You can use gsl_permute or reverse psl_permute_inverse () to perform gsl_permute_vector (_ inverse) () on the vector. Replace values can be multiplied.
Gsl_permutation_mul (). Similar permutation also has input and output functions. In addition, there is a regular expression for replacement, which can be converted using gsl_permutation_linear_to_canonical (), and a permutation can contain several cycle values.

Combinations combination gsl_combination.h
The structure is similar to replacement, but the combination problem is handled.

Sorting sorting gsl_heapsort.h, gsl_sort _ *. h
First, a heapsort, gsl_heapsort () and gsl_heapsort_index () supplemented by quick sort are provided (). You can use gsl_sort () or gsl_sort_vector () to sort arrays or vectors. In addition, there are also versions with indexes. You can use gsl_sort (_ vector) _ smallest/Largest (_ index) () to find the minimum/large k elements )().

Blas support basic linear algebra subroutines support gsl_blas.h, gsl_cblas.h
Blas supports three levels. Level 1 is vector, level 2 is matrix-vector, and level 3 is matrix-matrix. The operation object types are float, double, float complex, and double complex corresponding to sdcz. The features of the matrix are Ge (general), GB (General band matrix), and Sy (symmetric), Sb (symmetric band), SP (symmetric, packed), he, Hb, HP (Hermite), TR, TB, TP (triangular array ). Operation types include dot (inner product) and axpy (
X + Y), MV (matrix X vector), SV (matrix inverse multiplication vector), mm (matrix multiplication), Sm (matrix inverse multiplication another matrix ). The command format provided by GSL is gsl_blas _*.

Linear Algebra linear algebra gsl_linalg.h
This part includes the most common Linear numerical algebra operations, such as matrix Lu decomposition for Solving Linear Equations (with permutation, inplace, etc.), QR decomposition (including selected columns), SVD, cholesky decomposition, real symmetric matrix keralization decomposition (intrinsic decomposition), Hermite matrix keralization decomposition, real matrix hessenberg decomposition, real matrix pair hessenberg decomposition, Bidiagonalization ), householder transformation, Householder transformation to solve linear equations, three diagonal arrays, balancing (through similarity transformation makes the row and column norm equivalent ).

Eigensystems solves the feature value gsl_eigen.h
This part includes the feature values of the real symmetric matrix, the feature values of the Hermite matrix, the feature values of the asymmetric matrix (decomposed by Schur), and the functions for solving the corresponding generalized feature value problem. Generally, You Need To alloc a workspace, call the corresponding function to calculate the feature value and feature vector, and finally free the workspace. In addition, corresponding functions are provided for sorting feature values and feature vectors at the same time.

Fast Fourier Transform fast Fourier transformation gsl_fft _ *. h
Fast-speed Fourier transformation is divided into two types of processing: the complex number and the real number (more difficult, we need to ensure that the inverse transformation is the real number, and the halfcomplex expression coefficient is used. The Cooley-Tuckey algorithm can be directly used for power-times with data of 2. If not, there is another set of algorithms (workspace needs to be pre-allocated ). Each set of algorithms provides forward (Fourier transformation), inverse (inverse transformation), backward (inverse transformation without normalization constants), and transform (either forward or backward through parameters ).

Numerical Integration numeric integral gsl_integration.h
The name of the function is gsl_integration _ * (). Q indicates quadrature routine, N and A (indicating adaptive or not), G, and w (general points and points with weighted functions ), S and P (singular points that are easy to dissolve or points that are particularly difficult to provide), I (infinite points), O (oscillating points), F (Fourier points), and C (main value of the kernel ). When you set the Stop Condition in the integral, the relative error or absolute error is set.

Random Number Generation random number generator gsl_rsg.h
First, a corresponding type of gsl_rng_alloc () is required, and then gsl_rng_set () sets seed and gsl_rng_free () to release. You can also obtain the environment variables gsl_rng_type, gsl_rng_seed, And the gsl_rng_env_setup () function. Then, you can use the corresponding generator to generate a uniform distribution of [0, 1) by setting the corresponding generator, gsl_rng_uniform_pos () generates an even distribution of (0, 1) and gsl_rng_uniform_int () generates an even integer distribution within the specified range. You can also use
Gsl_rng_name () gets the name of the generator. gsl_rng_get () returns a random number between gsl_rng_min () and gsl_rng_max. If you need a more detailed processing generator, some functions are provided to process its State Io. Another chapter describes how to generate random numbers in various distributions.

Quasi random sequences pseudo-random sequence gsl_qrng.h
Unlike the previous chapter, the initial seed is not required. The call structure is similar to that of the previous chapter.

Random Number Distribution gsl_randist.h
This includes the vast majority of common distributions. The naming rules are as follows: gsl_ran_dist (_). Here dist is the distribution name, such as Gaussian. If there is no _, a random number is generated. If _ pdf is the density, the distribution function uses two forms: cdf_dist_p and cdf_dist_q, and corresponding inverse pinv and qinv. There are several types of distributions in total: Gaussian, gaussian_tail, bivariate_gaussian, exponential, Laplace, exppow, secrel, rayleigh_tail, Landau, Levy, levy_skew,
Gamma, flat, Lognormal, chisq, fdist, tdist, beta, logistic, Pareto, dir_2d, Weibo, gumbel1, gumbel2, and Dirichlet. For discrete distribution, you can use gsl_ran_discrete_preproc () to convert the distribution density column (or a scale factor difference) into a structure of the gsl_ran_discrete_t type, and pass it to gsl_ran_discrete, gsl_ran_discrete_pdf ()
Generate distribution columns. The generated structure can be released using gsl_ran_discrete_free. In addition, Poisson, Bernoulli, binomial, multinomial, negative_binomial, Pascal, geometric, hypergeometric, and logarithmic are provided. In addition to the distribution function, you can randomly disrupt the specified sequence gsl_ran_shuffle (), randomly select the element gsl_ran_choose (), and select a subset gsl_ran_sample ().

Statistics gsl_stats.h
The main requirement is to provide statistical functions, such as average gsl_stats_mean (), subsample variance (unbiased) gsl_stats_variance (), subsample variance (known expectations, biased) gsl_stats_variance_m (), standard Deviation: two versions: STD and std_m, and the expected sum of squares: TSS and tss_m. The other two versions are variance_with_fixed_mean and sd_with_fixed_mean. Absolute Deviation absdev and absdev_m, skew using skew, skew_m_sd, kurtosis and kurtosis_m_sd, self-correlation
Lagw.autocorrelation and lagw.autocorrelation_m, covariance and covariance_m, correlation coefficient correlation, and corresponding weighted versions plus W in front. In addition, the maximum and minimum values and corresponding index functions are provided to calculate the median and quantile values.

Histograms histogram gsl_hostogram *. h
There is not much difference between one dimension and two dimensions. We only need to add a new variable in one dimension and add a 2D variable after histogram. In general, gsl_histogram_alloc () is used to allocate space, gsl_histogram_set_ranges is used to set nodes (or uniform nodes using histogram (), and gsl_histogram_free (). In addition, gsl_histogram_memcpy () and gsl_histogram_clone ()
. You can use gsl_histogram_increment () to add elements to the count, or you can use gsl_histogram_accumulate () to add any weights (real numbers used for counters) to obtain the weights of a bin gsl_histogram_get (), or gsl_histogram_get_range () for a bin, gsl_histogram_min/MAX () for the entire histogram, and gsl_histogram_bins () for the bin, while gsl_histogram_reset ()
Clears the entire histogram. Gsl_histogram_find () returns the bin of a value. In addition, max/min_val/bin returns the maximum value or bin, and uses this histogram to calculate mean, SIGMA (standard deviation), and sum. The other two histograms can use gsl_histogram_equal_bins_p () to check whether Add/SUB/MUL/Div operations can be used. Shift allows all values + constants, and scale is multiplication. There are also some IO functions. You can use gsl_histogram
Create a gsl_histogram_pdf file, which is used like the preceding random number.

N-tuples n tuples gsl_ntuple.h
A simple data structure is used to write/read data to/from a file. gsl_ntuple_create () is used to create an empty file (truncation of existing files) and gsl_ntuple_open () open an existing file, or gsl_ntuple_write () to write ntuple to the file, or read the ntuple data gsl_ntuple_read () from the file. Finally, you need to close gsl_ntuple_close. You can read an ntuple data and feed it to histogram for statistics. This mainly uses the gsl_ntuple_project () function.

Monte Carlo integration Monte Carlo integral gsl_monte _ *. h
The three most basic integration methods are implemented. In gsl_monte .h, the basic form of the integral function is declared. gsl_monte _function provides the simplest method of uniformly sampling the integral function. First, gsl_monte _plain_alloc () allocate a workspace, initialize gsl_monte _plain_init (), gsl_monte _plain_integrate () points, and finally gsl_monte _plain_free () to release the workspace. In
The hierarchical Monte Carlo points in can be used to control the algorithm details using the gsl_monte _miser_state structure. Gsl_monte _vegas.h uses impartance sampling to control algorithm details. Complicated MCMC is not implemented here.

Simulated Annealing simulated annealing gsl_siman.h
Only one function, gsl_siman_solve (), provides optimization functions and other information.

Ordinary Differential Equations common differential equation gsl_odeiv.h
The main function must use the gsl_odeiv_system structure and provide functions and partial guidance in the standard form of equations (that is, the kalibana matrix ). In addition, the algorithm-related stepping function, such as The Runge-Kutta method, also has an adaptive version. This function aims to calculate the function value of a specified step. GSL also provides a function (evolve) for calculating the function variation (several steps) within a range ). However, I am not familiar with the numerical solutions of ordinary differential equations.

Interpolation interpolation gsl_spline.h, gsl_interp.h
Cubic splines and Akima splines are provided. Compared with low-level functions, this function provides users with very detailed control. You can use gsl_interp_alloc () to allocate the required space, select an appropriate algorithm, initialize the node gsl_interp_init (), and finally gsl_interp_free () release. You can use gsl_interp_bsearch () or gsl_interp_accel object (init first, find and free) to search for a location (so as to calculate the function value ). In addition, it provides the most common function values, the first-order guide, the second-order guide and points, and the corresponding gsl_interp_accel
. High-level functions are mainly provided in gsl_spline.h. Similar to the gsl_interp _ * series.

Numerical Difference Differential gsl_deriv.h
Provides the central differential gsl_derive_central (), forward gsl_deriv_forward (), and backward gsl_deriv_backward ().

Chebyshev approximation vivef approaches gsl_chebyshev.h
We provide a set of orthogonal polynomials above [-1, 1], which corresponds to the function space where 1/SQRT (^ 2) is weighted. First, use gsl_cheb_alloc () to allocate space to generate the gsl_cheb_series structure, then gsl_cheb_init (), and finally gsl_cheb_free (). Provides calculation function value, function value error, function guide and points.

Series acceleration series acceleration gsl_sum.h
I have never heard of Levin U-transform. The significance is to reduce the sum and improve the calculation accuracy. The usage is to allocate a workspace through gsl_sum_levin_u_alloc (), then allocate it through gsl_sum_levin_u_accel (), and finally gsl_sum_levin_free (). If you do not need to estimate the error, it can be faster.

Wavelet transform wavelet transform gsl_wavelet *. h
Similar to FFT, but there is no backward type, which is divided into one and two dimensions, including Daubechies, Haar, and bspline.

Discrete Hankel transform discrete Hankel transform gsl_dht.h
Similar to FFT, but for polar coordinates, the call method is similar to FFT.

One-dimen1_root finding one-dimensional function evaluate zero point gsl_roots.h
There are two methods (based on gsl_root_fsolver search and based on the derivative gsl_root_fdfsolver ). First select the appropriate solver. The naming method is gsl_root _ * solver_type, and then alloc. Then you can use gsl_root _ * solver_set () to set the initial state and start iteration using gsl_root _ * solver_iterate (). You can also use gsl_root _ * solver_root () to find the root. Gsl_root_fsolver_x_upper () and gsl_root_fsolver_x_lower ()
Returns the range of the control root. You can use gsl_root_test _ * () to test the relative error and residual error. The provided algorithms include bisection, falsepos, and Brent. The gradient algorithms include Newton, secant, and steffenson.

One-dimen1_minimization one-dimensional function minimum gsl_min.h
In a sense, minimization is to find the zero point of the function. Therefore, the call method is very similar to the previous chapter. The algorithms include goldensection and Brent.

Multi-dimen1_root finding multi-dimensional function evaluate zero point gsl_multiroots.h
Similar. The algorithms include hybridsj, hybridj, Newton, and gnewton. Algorithms without gradients include hybrids, hybrid, dnewton, and Broyden.

Multi-dimen1_minimization
Similar. The algorithms include conjugate_fr, conjugate_pr, BFGS, bfgs2, steepest_descent, and nmsimplex.

Least Square Fitting Least Squares Fitting gsl_fit.h
Separate single variables and multiple variables. Gsl_fit_linear () and gsl_fit_wlinear () are single-variable fitting (linear regression) for linear and weighted linear Problems, respectively. In addition, gsl_fit_linear_est () also estimates the error. The multivariate situations include gsl_fit_mul (), gsl_fit_wmul (), and gsl_fit_mul_linear (). For LSF problems in the broad sense, you need to use gsl_multifit_linear_alloc () to allocate the workspace and release it. Similar functions include gsl_multifit_linear and weighted.
Version. In addition, the _ SVD version uses the SVD calculation result.

Nonlinear Least Square Fitting gsl_multifit_nlin.h
Similar to minimizing multidimensional functions.

Basic splines basic spline gsl_bspline.h
First gsl_bspline_alloc () generates the workspace, then gsl_bspline_knots () or merge () sets the node, gsl_bspline_eval () calculates the function value, and finally gsl_bspline_free () releases the space.

Physical constants physical constant gsl_const_mksa.h
Various physical constants that may be used are generally named gsl_const_mksa _*.

IEEE Floating Point Arithmetic gsl_ieee_utils.h