— Function: int gsl_blas_sdsdot (float alpha, const gsl_vector_float * x, const gsl_vector_float * y, float * result)

This function computes the sum \alpha + x^T y for the vectors x and y, returning the result in result.

— Function: int gsl_blas_sdot (const gsl_vector_float * x, const gsl_vector_float * y, float * result)
— Function: int gsl_blas_dsdot (const gsl_vector_float * x, const gsl_vector_float * y, double * result)
— Function: int gsl_blas_ddot (const gsl_vector * x, const gsl_vector * y, double * result)

These functions compute the scalar product x^T y for the vectors x and y, returning the result in result.

— Function: int gsl_blas_cdotu (const gsl_vector_complex_float * x, const gsl_vector_complex_float * y, gsl_complex_float * dotu)
— Function: int gsl_blas_zdotu (const gsl_vector_complex * x, const gsl_vector_complex * y, gsl_complex * dotu)

These functions compute the complex scalar product x^T y for the vectors x and y, returning the result in result

— Function: int gsl_blas_cdotc (const gsl_vector_complex_float * x, const gsl_vector_complex_float * y, gsl_complex_float * dotc)
— Function: int gsl_blas_zdotc (const gsl_vector_complex * x, const gsl_vector_complex * y, gsl_complex * dotc)

These functions compute the complex conjugate scalar product x^H y for the vectors x and y, returning the result in result

— Function: float gsl_blas_snrm2 (const gsl_vector_float * x)
— Function: double gsl_blas_dnrm2 (const gsl_vector * x)

These functions compute the Euclidean norm ||x||_2 = \sqrt {\sum x_i^2} of the vector x.

— Function: float gsl_blas_scnrm2 (const gsl_vector_complex_float * x)
— Function: double gsl_blas_dznrm2 (const gsl_vector_complex * x)

These functions compute the Euclidean norm of the complex vector x,

          ||x||_2 = \sqrt {\sum (\Re(x_i)^2 + \Im(x_i)^2)}.

— Function: float gsl_blas_sasum (const gsl_vector_float * x)
— Function: double gsl_blas_dasum (const gsl_vector * x)

These functions compute the absolute sum \sum |x_i| of the elements of the vector x.

— Function: float gsl_blas_scasum (const gsl_vector_complex_float * x)
— Function: double gsl_blas_dzasum (const gsl_vector_complex * x)

These functions compute the sum of the magnitudes of the real and imaginary parts of the complex vector x, \sum |\Re(x_i)| + |\Im(x_i)|.

— Function: CBLAS_INDEX_t gsl_blas_isamax (const gsl_vector_float * x)
— Function: CBLAS_INDEX_t gsl_blas_idamax (const gsl_vector * x)
— Function: CBLAS_INDEX_t gsl_blas_icamax (const gsl_vector_complex_float * x)
— Function: CBLAS_INDEX_t gsl_blas_izamax (const gsl_vector_complex * x)

These functions return the index of the largest element of the vector x. The largest element is determined by its absolute magnitude for real vectors and by the sum of the magnitudes of the real and imaginary parts |\Re(x_i)| + |\Im(x_i)| for complex vectors. If the largest value occurs several times then the index of the first occurrence is returned.

— Function: int gsl_blas_sswap (gsl_vector_float * x, gsl_vector_float * y)
— Function: int gsl_blas_dswap (gsl_vector * x, gsl_vector * y)
— Function: int gsl_blas_cswap (gsl_vector_complex_float * x, gsl_vector_complex_float * y)
— Function: int gsl_blas_zswap (gsl_vector_complex * x, gsl_vector_complex * y)

These functions exchange the elements of the vectors x and y.

— Function: int gsl_blas_scopy (const gsl_vector_float * x, gsl_vector_float * y)
— Function: int gsl_blas_dcopy (const gsl_vector * x, gsl_vector * y)
— Function: int gsl_blas_ccopy (const gsl_vector_complex_float * x, gsl_vector_complex_float * y)
— Function: int gsl_blas_zcopy (const gsl_vector_complex * x, gsl_vector_complex * y)

These functions copy the elements of the vector x into the vector y.

— Function: int gsl_blas_saxpy (float alpha, const gsl_vector_float * x, gsl_vector_float * y)
— Function: int gsl_blas_daxpy (double alpha, const gsl_vector * x, gsl_vector * y)
— Function: int gsl_blas_caxpy (const gsl_complex_float alpha, const gsl_vector_complex_float * x, gsl_vector_complex_float * y)
— Function: int gsl_blas_zaxpy (const gsl_complex alpha, const gsl_vector_complex * x, gsl_vector_complex * y)

These functions compute the sum y = \alpha x + y for the vectors x and y.

— Function: void gsl_blas_sscal (float alpha, gsl_vector_float * x)
— Function: void gsl_blas_dscal (double alpha, gsl_vector * x)
— Function: void gsl_blas_cscal (const gsl_complex_float alpha, gsl_vector_complex_float * x)
— Function: void gsl_blas_zscal (const gsl_complex alpha, gsl_vector_complex * x)
— Function: void gsl_blas_csscal (float alpha, gsl_vector_complex_float * x)
— Function: void gsl_blas_zdscal (double alpha, gsl_vector_complex * x)

These functions rescale the vector x by the multiplicative factor alpha.

— Function: int gsl_blas_srotg (float a[], float b[], float c[], float s[])
— Function: int gsl_blas_drotg (double a[], double b[], double c[], double s[])

These functions compute a Givens rotation (c,s) which zeroes the vector (a,b),

          [  c  s ] [ a ] = [ r ]
          [ -s  c ] [ b ]   [ 0 ]

The variables a and b are overwritten by the routine.

— Function: int gsl_blas_srot (gsl_vector_float * x, gsl_vector_float * y, float c, float s)
— Function: int gsl_blas_drot (gsl_vector * x, gsl_vector * y, const double c, const double s)

These functions apply a Givens rotation (x', y') = (c x + s y, -s x + c y) to the vectors x, y.

— Function: int gsl_blas_srotmg (float d1[], float d2[], float b1[], float b2, float P[])
— Function: int gsl_blas_drotmg (double d1[], double d2[], double b1[], double b2, double P[])

These functions compute a modified Givens transformation. The modified Givens transformation is defined in the original Level-1 blas specification, given in the references.

— Function: int gsl_blas_srotm (gsl_vector_float * x, gsl_vector_float * y, const float P[])
— Function: int gsl_blas_drotm (gsl_vector * x, gsl_vector * y, const double P[])

These functions apply a modified Givens transformation.