/** * C++ version of gsl_blas_sger(). * @param alpha A constant * @param X A vector * @param Y A vector * @param A A matrix * @return Error code on failure */ int sger( float alpha, vector_float const& X, vector_float const& Y, matrix_float& A ){ return gsl_blas_sger( alpha, X.get(), Y.get(), A.get() ); }
/** * C++ version of gsl_blas_ssyr2(). * @param Uplo Upper or lower triangular * @param alpha A constant * @param X A vector * @param Y A vector * @param A A matrix * @return Error code on failure */ int ssyr2( CBLAS_UPLO_t Uplo, float alpha, vector_float const& X, vector_float const& Y, matrix_float& A ){ return gsl_blas_ssyr2( Uplo, alpha, X.get(), Y.get(), A.get() ); }
/** * C++ version of gsl_blas_strsv(). * @param Uplo Upper or lower triangular * @param TransA Transpose type * @param Diag Diagonal type * @param A A matrix * @param X A vector * @return Error code on failure */ int strsv( CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, matrix_float const& A, vector_float& X ){ return gsl_blas_strsv( Uplo, TransA, Diag, A.get(), X.get() ); }
/** * C++ version of gsl_blas_ssymv(). * @param Uplo Upper or lower triangular * @param alpha A constant * @param A A matrix * @param X A vector * @param beta Another constant * @param Y A vector * @return Error code on failure */ int ssymv( CBLAS_UPLO_t Uplo, float alpha, matrix_float const& A, vector_float const& X, float beta, vector_float& Y ){ return gsl_blas_ssymv( Uplo, alpha, A.get(), X.get(), beta, Y.get() ); }
/** * C++ version of gsl_blas_sscal(). * @param alpha A constant * @param X A vector */ void sscal( float alpha, vector_float& X ){ gsl_blas_sscal( alpha, X.get() ); }
/** * C++ version of gsl_blas_sgemv(). * @param TransA Transpose type * @param alpha A constant * @param A A matrix * @param X A vector * @param beta Another constant * @param Y A vector * @return Error code on failure */ int sgemv( CBLAS_TRANSPOSE_t TransA, float alpha, matrix_float const& A, vector_float const& X, float beta, vector_float& Y ){ return gsl_blas_sgemv( TransA, alpha, A.get(), X.get(), beta, Y.get() ); }
/** * C++ version of gsl_blas_srot(). * @param X A vector * @param Y A vector * @param c A constant * @param s A constant * @return Error code on failure */ int srot( vector_float& X, vector_float& Y, float c, float s ){ return gsl_blas_srot( X.get(), Y.get(), c, s ); }
/** * C++ version of gsl_blas_snrm2(). * @param X A vector * @return The Euclidean norm */ float snrm2( vector_float const& X ){ return gsl_blas_snrm2( X.get() ); }
/** * C++ version of gsl_blas_scopy(). * @param X A vector * @param Y A vector * @return Error code on failure */ int scopy( vector_float const& X, vector_float& Y ){ return gsl_blas_scopy( X.get(), Y.get() ); }
/** * C++ version of gsl_blas_saxpy(). * @param alpha A vector * @param X A vector * @param Y A vector * @return Error code on failure */ int saxpy( float alpha, vector_float const& X, vector_float& Y ){ return gsl_blas_saxpy( alpha, X.get(), Y.get() ); }
/** * C++ version of gsl_blas_sswap(). * @param X A vector * @param Y A vector * @return Error code on failure */ int sswap( vector_float& X, vector_float& Y ){ return gsl_blas_sswap( X.get(), Y.get() ); }
/** * C++ version of gsl_blas_isamax(). * @param X A vector * @return Index of the largest-magnitude element */ CBLAS_INDEX_t isamax( vector_float const& X ){ return gsl_blas_isamax( X.get() ); }
/** * C++ version of gsl_blas_sasum(). * @param X A vector * @return The absolute sum of the elements */ float sasum( vector_float const& X ){ return gsl_blas_sasum( X.get() ); }
/** * C++ version of gsl_blas_dsdot(). * @param X First vector * @param Y Second vector * @param result Vector product * @return Error code on failure */ int dsdot( vector_float const& X, vector_float const& Y, double* result ){ return gsl_blas_dsdot( X.get(), Y.get(), result ); }
/** * C++ version of gsl_blas_srotm(). * @param X A vector * @param Y A vector * @param P An array * @return Error code on failure */ int srotm( vector_float& X, vector_float& Y, float const P[] ){ return gsl_blas_srotm( X.get(), Y.get(), P ); }
/** * C++ version of gsl_blas_sdot(). * @param X First vector * @param Y Second vector * @param result Vector product * @return Error code on failure */ int sdot( vector_float const& X, vector_float const& Y, float* result ){ return gsl_blas_sdot( X.get(), Y.get(), result ); }
/** * C++ version of gsl_permute_vector_float_inverse(). * @param p A permutation * @param v A vector * @return Error code on failure */ inline int vector_float_inverse( permutation const& p, vector_float& v ){ return gsl_permute_vector_float_inverse( p.get(), v.get() ); }