monolish::blas Namespace Reference

Basic Linear Algebra Subprograms for Dense Matrix, Sparse Matrix, Vector and Scalar. More...

Functions
double	asum (const vector< double > &x)
	vector<float> asum (absolute sum) More...
void	asum (const vector< double > &x, double &ans)
	vector<float> asum (absolute sum) More...
float	asum (const vector< float > &x)
void	asum (const vector< float > &x, float &ans)
double	asum (const view1D< matrix::Dense< double >, double > &x)
void	asum (const view1D< matrix::Dense< double >, double > &x, double &ans)
float	asum (const view1D< matrix::Dense< float >, float > &x)
void	asum (const view1D< matrix::Dense< float >, float > &x, float &ans)
double	asum (const view1D< vector< double >, double > &x)
void	asum (const view1D< vector< double >, double > &x, double &ans)
float	asum (const view1D< vector< float >, float > &x)
void	asum (const view1D< vector< float >, float > &x, float &ans)
void	axpy (const double alpha, const vector< double > &x, vector< double > &y)
	axpy: y = ax + y More...
void	axpy (const double alpha, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	axpy (const double alpha, const vector< double > &x, view1D< vector< double >, double > &y)
void	axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	axpy (const double alpha, const view1D< vector< double >, double > &x, vector< double > &y)
void	axpy (const double alpha, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	axpy (const double alpha, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	axpy (const float alpha, const vector< float > &x, vector< float > &y)
void	axpy (const float alpha, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	axpy (const float alpha, const vector< float > &x, view1D< vector< float >, float > &y)
void	axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	axpy (const float alpha, const view1D< vector< float >, float > &x, vector< float > &y)
void	axpy (const float alpha, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	axpy (const float alpha, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
void	axpyz (const double alpha, const vector< double > &x, const vector< double > &y, vector< double > &z)
	axpyz: z = ax + y More...
void	axpyz (const double alpha, const vector< double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const vector< double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
void	axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
void	axpyz (const float alpha, const vector< float > &x, const vector< float > &y, vector< float > &z)
void	axpyz (const float alpha, const vector< float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const vector< float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
void	axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
void	copy (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	CRS matrix copy (y=a) More...
void	copy (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	copy (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	Dense matrix copy (C=A) More...
void	copy (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	copy (const matrix::LinearOperator< double > &A, matrix::LinearOperator< double > &C)
	LinearOperator copy (C=A) More...
void	copy (const matrix::LinearOperator< float > &A, matrix::LinearOperator< float > &C)
void	copy (const vector< double > &x, vector< double > &y)
	vector<float> copy (y=x) More...
void	copy (const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	copy (const vector< double > &x, view1D< vector< double >, double > &y)
void	copy (const vector< float > &x, vector< float > &y)
void	copy (const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	copy (const vector< float > &x, view1D< vector< float >, float > &y)
void	copy (const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	copy (const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	copy (const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	copy (const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	copy (const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	copy (const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	copy (const view1D< vector< double >, double > &x, vector< double > &y)
void	copy (const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	copy (const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	copy (const view1D< vector< float >, float > &x, vector< float > &y)
void	copy (const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	copy (const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
double	dot (const vector< double > &x, const vector< double > &y)
	inner product (dot) More...
void	dot (const vector< double > &x, const vector< double > &y, double &ans)
	inner product (dot) More...
double	dot (const vector< double > &x, const view1D< matrix::Dense< double >, double > &y)
void	dot (const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
double	dot (const vector< double > &x, const view1D< vector< double >, double > &y)
void	dot (const vector< double > &x, const view1D< vector< double >, double > &y, double &ans)
float	dot (const vector< float > &x, const vector< float > &y)
void	dot (const vector< float > &x, const vector< float > &y, float &ans)
float	dot (const vector< float > &x, const view1D< matrix::Dense< float >, float > &y)
void	dot (const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
float	dot (const vector< float > &x, const view1D< vector< float >, float > &y)
void	dot (const vector< float > &x, const view1D< vector< float >, float > &y, float &ans)
double	dot (const view1D< matrix::Dense< double >, double > &x, const vector< double > &y)
void	dot (const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, double &ans)
double	dot (const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)
void	dot (const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
double	dot (const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y)
void	dot (const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, double &ans)
float	dot (const view1D< matrix::Dense< float >, float > &x, const vector< float > &y)
void	dot (const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, float &ans)
float	dot (const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)
void	dot (const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
float	dot (const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y)
void	dot (const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, float &ans)
double	dot (const view1D< vector< double >, double > &x, const vector< double > &y)
void	dot (const view1D< vector< double >, double > &x, const vector< double > &y, double &ans)
double	dot (const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)
void	dot (const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
double	dot (const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y)
void	dot (const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, double &ans)
float	dot (const view1D< vector< float >, float > &x, const vector< float > &y)
void	dot (const view1D< vector< float >, float > &x, const vector< float > &y, float &ans)
float	dot (const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)
void	dot (const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
float	dot (const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y)
void	dot (const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, float &ans)
void	matadd (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	CRS matrix addition: C = A + B (A and B must be same non-zero structure) More...
void	matadd (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	matadd (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Dense matrix addition: C = A + B. More...
void	matadd (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	matadd (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	LinearOperator addition: C = A + B. More...
void	matadd (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)
void	matmul (const matrix::CRS< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	CRS and Dense matrix multiplication: C = AB. More...
void	matmul (const matrix::CRS< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	matmul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Dense matrix multiplication: C = AB. More...
void	matmul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	matmul (const matrix::LinearOperator< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	LinearOperator multiplication: C = AB. More...
void	matmul (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	LinearOperator multiplication: C = AB. More...
void	matmul (const matrix::LinearOperator< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	matmul (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)
void	matsub (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	CRS matrix subtract: C = A - B (A and B must be same non-zero structure) More...
void	matsub (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	matsub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Dense matrix subtract: C = A - B. More...
void	matsub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	matsub (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	LinearOperator subtract: C = A - B. More...
void	matsub (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)
void	matvec (const matrix::CRS< double > &A, const vector< double > &x, vector< double > &y)
	sparse matrix (CRS) and vector multiplication: y = Ax More...
void	matvec (const matrix::CRS< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::CRS< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::CRS< float > &A, const vector< float > &x, vector< float > &y)
void	matvec (const matrix::CRS< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::CRS< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::Dense< double > &A, const vector< double > &x, vector< double > &y)
	Dense matrix and vector multiplication: y = Ax. More...
void	matvec (const matrix::Dense< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::Dense< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::Dense< float > &A, const vector< float > &x, vector< float > &y)
void	matvec (const matrix::Dense< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::Dense< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, vector< double > &y)
	matrix (LinearOperator) and vector multiplication: y = Ax More...
void	matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, vector< float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
void	mscal (const double alpha, matrix::CRS< double > &A)
	CRS matrix scal: A = alpha * A. More...
void	mscal (const double alpha, matrix::Dense< double > &A)
	Densematrix scal: A = alpha * A. More...
void	mscal (const float alpha, matrix::CRS< float > &A)
void	mscal (const float alpha, matrix::Dense< float > &A)
double	nrm1 (const vector< double > &x)
	nrm1: sum(abs(x[0:N])) More...
void	nrm1 (const vector< double > &x, double &ans)
	nrm1: sum(abs(x[0:N])) More...
float	nrm1 (const vector< float > &x)
void	nrm1 (const vector< float > &x, float &ans)
double	nrm1 (const view1D< matrix::Dense< double >, double > &x)
void	nrm1 (const view1D< matrix::Dense< double >, double > &x, double &ans)
float	nrm1 (const view1D< matrix::Dense< float >, float > &x)
void	nrm1 (const view1D< matrix::Dense< float >, float > &x, float &ans)
double	nrm1 (const view1D< vector< double >, double > &x)
void	nrm1 (const view1D< vector< double >, double > &x, double &ans)
float	nrm1 (const view1D< vector< float >, float > &x)
void	nrm1 (const view1D< vector< float >, float > &x, float &ans)
double	nrm2 (const vector< double > &x)
	nrm2: ||x||_2 More...
void	nrm2 (const vector< double > &x, double &ans)
	nrm2: ||x||_2 More...
float	nrm2 (const vector< float > &x)
void	nrm2 (const vector< float > &x, float &ans)
double	nrm2 (const view1D< matrix::Dense< double >, double > &x)
void	nrm2 (const view1D< matrix::Dense< double >, double > &x, double &ans)
float	nrm2 (const view1D< matrix::Dense< float >, float > &x)
void	nrm2 (const view1D< matrix::Dense< float >, float > &x, float &ans)
double	nrm2 (const view1D< vector< double >, double > &x)
void	nrm2 (const view1D< vector< double >, double > &x, double &ans)
float	nrm2 (const view1D< vector< float >, float > &x)
void	nrm2 (const view1D< vector< float >, float > &x, float &ans)
void	rmatmul (const matrix::LinearOperator< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	LinearOperator multiplication: C = A^t B. More...
void	rmatmul (const matrix::LinearOperator< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, vector< double > &y)
	matrix (LinearOperator) and vector multiplication: y = Ax More...
void	rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, vector< float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
void	scal (const double alpha, vector< double > &x)
	scal: x = alpha * x More...
void	scal (const double alpha, view1D< matrix::Dense< double >, double > &x)
void	scal (const double alpha, view1D< vector< double >, double > &x)
void	scal (const float alpha, vector< float > &x)
void	scal (const float alpha, view1D< matrix::Dense< float >, float > &x)
void	scal (const float alpha, view1D< vector< float >, float > &x)
double	sum (const vector< double > &x)
	vector<float> sum More...
void	sum (const vector< double > &x, double &ans)
	vector<float> sum More...
float	sum (const vector< float > &x)
void	sum (const vector< float > &x, float &ans)
double	sum (const view1D< matrix::Dense< double >, double > &x)
void	sum (const view1D< matrix::Dense< double >, double > &x, double &ans)
float	sum (const view1D< matrix::Dense< float >, float > &x)
void	sum (const view1D< matrix::Dense< float >, float > &x, float &ans)
double	sum (const view1D< vector< double >, double > &x)
void	sum (const view1D< vector< double >, double > &x, double &ans)
float	sum (const view1D< vector< float >, float > &x)
void	sum (const view1D< vector< float >, float > &x, float &ans)
void	vecadd (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element addition of vector a and vector b. More...
void	vecadd (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	vecadd (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element subtract of vector a and vector b. More...
void	vecsub (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	vecsub (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	xpay (const double alpha, const vector< double > &x, vector< double > &y)
	xpay: y = x + ay More...
void	xpay (const double alpha, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
void	xpay (const double alpha, const vector< double > &x, view1D< vector< double >, double > &y)
void	xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
void	xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
void	xpay (const double alpha, const view1D< vector< double >, double > &x, vector< double > &y)
void	xpay (const double alpha, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
void	xpay (const double alpha, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
void	xpay (const float alpha, const vector< float > &x, vector< float > &y)
void	xpay (const float alpha, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
void	xpay (const float alpha, const vector< float > &x, view1D< vector< float >, float > &y)
void	xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
void	xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
void	xpay (const float alpha, const view1D< vector< float >, float > &x, vector< float > &y)
void	xpay (const float alpha, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
void	xpay (const float alpha, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

Detailed Description

Basic Linear Algebra Subprograms for Dense Matrix, Sparse Matrix, Vector and Scalar.

Function Documentation

asum() [1/12]

double monolish::blas::asum

(

const vector< double > &

x

)

vector<float> asum (absolute sum)

Parameters

x	monolish vector<float> (size N)

Returns

The result of the asum

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

asum() [2/12]

void monolish::blas::asum	(	const vector< double > &	x,
		double &	ans
	)

vector<float> asum (absolute sum)

Parameters

x	monolish vector<float> (size N)
ans	The result of the asum

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

asum() [3/12]

float monolish::blas::asum

(

const vector< float > &

x

)

asum() [4/12]

void monolish::blas::asum	(	const vector< float > &	x,
		float &	ans
	)

asum() [5/12]

double monolish::blas::asum

(

const view1D< matrix::Dense< double >, double > &

x

)

asum() [6/12]

void monolish::blas::asum	(	const view1D< matrix::Dense< double >, double > &	x,
		double &	ans
	)

asum() [7/12]

float monolish::blas::asum

(

const view1D< matrix::Dense< float >, float > &

x

)

asum() [8/12]

void monolish::blas::asum	(	const view1D< matrix::Dense< float >, float > &	x,
		float &	ans
	)

asum() [9/12]

double monolish::blas::asum

(

const view1D< vector< double >, double > &

x

)

asum() [10/12]

void monolish::blas::asum	(	const view1D< vector< double >, double > &	x,
		double &	ans
	)

asum() [11/12]

float monolish::blas::asum

(

const view1D< vector< float >, float > &

x

)

asum() [12/12]

void monolish::blas::asum	(	const view1D< vector< float >, float > &	x,
		float &	ans
	)

axpy() [1/18]

void monolish::blas::axpy	(	const double	alpha,
		const vector< double > &	x,
		vector< double > &	y
	)

axpy: y = ax + y

Parameters

alpha	scalar value
x	monolish vector<float> (size N)
y	monolish vector<float> (size N)

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

axpy() [2/18]

void monolish::blas::axpy	(	const double	alpha,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

axpy() [3/18]

void monolish::blas::axpy	(	const double	alpha,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

axpy() [4/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

axpy() [5/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

axpy() [6/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

axpy() [7/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

axpy() [8/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

axpy() [9/18]

void monolish::blas::axpy	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

axpy() [10/18]

void monolish::blas::axpy	(	const float	alpha,
		const vector< float > &	x,
		vector< float > &	y
	)

axpy() [11/18]

void monolish::blas::axpy	(	const float	alpha,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

axpy() [12/18]

void monolish::blas::axpy	(	const float	alpha,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

axpy() [13/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

axpy() [14/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

axpy() [15/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

axpy() [16/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

axpy() [17/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

axpy() [18/18]

void monolish::blas::axpy	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

axpyz() [1/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const vector< double > &	y,
		vector< double > &	z
	)

axpyz: z = ax + y

Parameters

alpha	scalar value
x	monolish vector<float> (size N)
y	monolish vector<float> (size N)
z	monolish vector<float> (size N)

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

axpyz() [2/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const vector< double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [3/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const vector< double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [4/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [5/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [6/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [7/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [8/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [9/54]

void monolish::blas::axpyz	(	const double	alpha,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [10/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y,
		vector< double > &	z
	)

axpyz() [11/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [12/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [13/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [14/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [15/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [16/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [17/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [18/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [19/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y,
		vector< double > &	z
	)

axpyz() [20/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [21/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [22/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [23/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [24/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [25/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		vector< double > &	z
	)

axpyz() [26/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< matrix::Dense< double >, double > &	z
	)

axpyz() [27/54]

void monolish::blas::axpyz	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		view1D< vector< double >, double > &	z
	)

axpyz() [28/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const vector< float > &	y,
		vector< float > &	z
	)

axpyz() [29/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const vector< float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [30/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const vector< float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [31/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [32/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [33/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [34/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [35/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [36/54]

void monolish::blas::axpyz	(	const float	alpha,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [37/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y,
		vector< float > &	z
	)

axpyz() [38/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [39/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [40/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [41/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [42/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [43/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [44/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [45/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [46/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y,
		vector< float > &	z
	)

axpyz() [47/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [48/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [49/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [50/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [51/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

axpyz() [52/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		vector< float > &	z
	)

axpyz() [53/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< matrix::Dense< float >, float > &	z
	)

axpyz() [54/54]

void monolish::blas::axpyz	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		view1D< vector< float >, float > &	z
	)

copy() [1/24]

void monolish::blas::copy	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

CRS matrix copy (y=a)

Parameters

A	monolish CRS matrix (size M x N)
C	monolish CRS matrix (size M x N)

Note

• # of computation: M x N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

Warning

A and C must be same non-zero structure

copy() [2/24]

void monolish::blas::copy	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

copy() [3/24]

void monolish::blas::copy	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

Dense matrix copy (C=A)

Parameters

A	monolish Dense matrix (size M x N)
C	monolish Dense matrix (size M x N)

Note

• # of computation: M x N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

copy() [4/24]

void monolish::blas::copy	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

copy() [5/24]

void monolish::blas::copy	(	const matrix::LinearOperator< double > &	A,
		matrix::LinearOperator< double > &	C
	)

LinearOperator copy (C=A)

Parameters

A	monolish LinearOperator (size M x N)
C	monolish LinearOperator (size M x N)

Note

• # of computation: M x N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

copy() [6/24]

void monolish::blas::copy	(	const matrix::LinearOperator< float > &	A,
		matrix::LinearOperator< float > &	C
	)

copy() [7/24]

void monolish::blas::copy	(	const vector< double > &	x,
		vector< double > &	y
	)

vector<float> copy (y=x)

Parameters

x	monolish vector<float> (size N)
y	monolish vector<float> (size N)

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

copy() [8/24]

void monolish::blas::copy	(	const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

copy() [9/24]

void monolish::blas::copy	(	const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

copy() [10/24]

void monolish::blas::copy	(	const vector< float > &	x,
		vector< float > &	y
	)

copy() [11/24]

void monolish::blas::copy	(	const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

copy() [12/24]

void monolish::blas::copy	(	const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

copy() [13/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

copy() [14/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

copy() [15/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

copy() [16/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

copy() [17/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

copy() [18/24]

void monolish::blas::copy	(	const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

copy() [19/24]

void monolish::blas::copy	(	const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

copy() [20/24]

void monolish::blas::copy	(	const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

copy() [21/24]

void monolish::blas::copy	(	const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

copy() [22/24]

void monolish::blas::copy	(	const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

copy() [23/24]

void monolish::blas::copy	(	const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

copy() [24/24]

void monolish::blas::copy	(	const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

dot() [1/36]

double monolish::blas::dot	(	const vector< double > &	x,
		const vector< double > &	y
	)

inner product (dot)

Parameters

x	monolish vector<float> (size N)
y	monolish vector<float> (size N)

Returns

The result of the inner product product of x and y

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

dot() [2/36]

void monolish::blas::dot	(	const vector< double > &	x,
		const vector< double > &	y,
		double &	ans
	)

inner product (dot)

Parameters

x	monolish vector<float> (size N)
y	monolish vector<float> (size N)
ans	The result of the inner product product of x and y

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

dot() [3/36]

double monolish::blas::dot	(	const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

dot() [4/36]

void monolish::blas::dot	(	const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		double &	ans
	)

dot() [5/36]

double monolish::blas::dot	(	const vector< double > &	x,
		const view1D< vector< double >, double > &	y
	)

dot() [6/36]

void monolish::blas::dot	(	const vector< double > &	x,
		const view1D< vector< double >, double > &	y,
		double &	ans
	)

dot() [7/36]

float monolish::blas::dot	(	const vector< float > &	x,
		const vector< float > &	y
	)

dot() [8/36]

void monolish::blas::dot	(	const vector< float > &	x,
		const vector< float > &	y,
		float &	ans
	)

dot() [9/36]

float monolish::blas::dot	(	const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

dot() [10/36]

void monolish::blas::dot	(	const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		float &	ans
	)

dot() [11/36]

float monolish::blas::dot	(	const vector< float > &	x,
		const view1D< vector< float >, float > &	y
	)

dot() [12/36]

void monolish::blas::dot	(	const vector< float > &	x,
		const view1D< vector< float >, float > &	y,
		float &	ans
	)

dot() [13/36]

double monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y
	)

dot() [14/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y,
		double &	ans
	)

dot() [15/36]

double monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

dot() [16/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		double &	ans
	)

dot() [17/36]

double monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

dot() [18/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		double &	ans
	)

dot() [19/36]

float monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y
	)

dot() [20/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y,
		float &	ans
	)

dot() [21/36]

float monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

dot() [22/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		float &	ans
	)

dot() [23/36]

float monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

dot() [24/36]

void monolish::blas::dot	(	const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		float &	ans
	)

dot() [25/36]

double monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const vector< double > &	y
	)

dot() [26/36]

void monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const vector< double > &	y,
		double &	ans
	)

dot() [27/36]

double monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

dot() [28/36]

void monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y,
		double &	ans
	)

dot() [29/36]

double monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

dot() [30/36]

void monolish::blas::dot	(	const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y,
		double &	ans
	)

dot() [31/36]

float monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const vector< float > &	y
	)

dot() [32/36]

void monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const vector< float > &	y,
		float &	ans
	)

dot() [33/36]

float monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

dot() [34/36]

void monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y,
		float &	ans
	)

dot() [35/36]

float monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

dot() [36/36]

void monolish::blas::dot	(	const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y,
		float &	ans
	)

matadd() [1/6]

void monolish::blas::matadd	(	const matrix::CRS< double > &	A,
		const matrix::CRS< double > &	B,
		matrix::CRS< double > &	C
	)

CRS matrix addition: C = A + B (A and B must be same non-zero structure)

Parameters

A	CRS matrix (size M x N)
B	CRS matrix (size M x N)
C	CRS matrix (size M x N)

Note

• # of computation: nnz
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

Warning

A and B must be same non-zero structure

matadd() [2/6]

void monolish::blas::matadd	(	const matrix::CRS< float > &	A,
		const matrix::CRS< float > &	B,
		matrix::CRS< float > &	C
	)

matadd() [3/6]

void monolish::blas::matadd	(	const matrix::Dense< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

Dense matrix addition: C = A + B.

Parameters

A	Dense matrix (size M x N)
B	Dense matrix (size M x N)
C	Dense matrix (size M x N)

Note

• # of computation: MN
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matadd() [4/6]

void monolish::blas::matadd	(	const matrix::Dense< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

matadd() [5/6]

void monolish::blas::matadd	(	const matrix::LinearOperator< double > &	A,
		const matrix::LinearOperator< double > &	B,
		matrix::LinearOperator< double > &	C
	)

LinearOperator addition: C = A + B.

Parameters

A	LinearOperator (size M x N)
B	LinearOperator (size M x N)
C	LinearOperator (size M x N)

Note

• # of computation: 2 functions
• Multi-threading: false
• GPU acceleration: false

matadd() [6/6]

void monolish::blas::matadd	(	const matrix::LinearOperator< float > &	A,
		const matrix::LinearOperator< float > &	B,
		matrix::LinearOperator< float > &	C
	)

matmul() [1/8]

void monolish::blas::matmul	(	const matrix::CRS< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

CRS and Dense matrix multiplication: C = AB.

Parameters

A	CRS matrix (size M x K)
B	Dense matrix (size K x N)
C	Dense matrix (size M x N)

Note

• # of computation: 2*N*nnz
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matmul() [2/8]

void monolish::blas::matmul	(	const matrix::CRS< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

matmul() [3/8]

void monolish::blas::matmul	(	const matrix::Dense< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

Dense matrix multiplication: C = AB.

Parameters

A	Dense matrix (size M x K)
B	Dense matrix (size K x N)
C	Dense matrix (size M x N)

Note

• # of computation: 2MNK
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matmul() [4/8]

void monolish::blas::matmul	(	const matrix::Dense< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

matmul() [5/8]

void monolish::blas::matmul	(	const matrix::LinearOperator< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

LinearOperator multiplication: C = AB.

Parameters

A	LinearOperator (size M x K)
B	Dense matrix (size K x N)
C	Dense matrix (size M x N)

Note

• # of computation: ?
• Multi-threading: false
• GPU acceleration: false

matmul() [6/8]

void monolish::blas::matmul	(	const matrix::LinearOperator< double > &	A,
		const matrix::LinearOperator< double > &	B,
		matrix::LinearOperator< double > &	C
	)

LinearOperator multiplication: C = AB.

Parameters

A	LinearOperator (size M x K)
B	LinearOperator (size K x N)
C	LinearOperator (size M x N)

Note

• # of computation: 2 functions
• Multi-threading: false
• GPU acceleration: false

matmul() [7/8]

void monolish::blas::matmul	(	const matrix::LinearOperator< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

matmul() [8/8]

void monolish::blas::matmul	(	const matrix::LinearOperator< float > &	A,
		const matrix::LinearOperator< float > &	B,
		matrix::LinearOperator< float > &	C
	)

matsub() [1/6]

void monolish::blas::matsub	(	const matrix::CRS< double > &	A,
		const matrix::CRS< double > &	B,
		matrix::CRS< double > &	C
	)

CRS matrix subtract: C = A - B (A and B must be same non-zero structure)

Parameters

A	CRS matrix (size M x N)
B	CRS matrix (size M x N)
C	CRS matrix (size M x N)

Note

• # of computation: nnz
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

Warning

A B must be same non-zero structure

matsub() [2/6]

void monolish::blas::matsub	(	const matrix::CRS< float > &	A,
		const matrix::CRS< float > &	B,
		matrix::CRS< float > &	C
	)

matsub() [3/6]

void monolish::blas::matsub	(	const matrix::Dense< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

Dense matrix subtract: C = A - B.

Parameters

A	Dense matrix (size M x N)
B	Dense matrix (size M x N)
C	Dense matrix (size M x N)

Note

• # of computation: MN
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matsub() [4/6]

void monolish::blas::matsub	(	const matrix::Dense< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

matsub() [5/6]

void monolish::blas::matsub	(	const matrix::LinearOperator< double > &	A,
		const matrix::LinearOperator< double > &	B,
		matrix::LinearOperator< double > &	C
	)

LinearOperator subtract: C = A - B.

Parameters

A	LinearOperator (size M x N)
B	LinearOperator (size M x N)
C	LinearOperator (size M x N)

Note

• # of computation: 2 functions
• Multi-threading: false
• GPU acceleration: false

matsub() [6/6]

void monolish::blas::matsub	(	const matrix::LinearOperator< float > &	A,
		const matrix::LinearOperator< float > &	B,
		matrix::LinearOperator< float > &	C
	)

matvec() [1/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		vector< double > &	y
	)

sparse matrix (CRS) and vector multiplication: y = Ax

Parameters

A	CRS matrix (size M x N)
x	monolish vector (size M)
y	monolish vector (size M)

Note

• # of computation: 2nnz
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matvec() [2/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [3/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [4/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

matvec() [5/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [6/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [7/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

matvec() [8/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [9/54]

void monolish::blas::matvec	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [10/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		vector< float > &	y
	)

matvec() [11/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [12/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [13/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

matvec() [14/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [15/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [16/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

matvec() [17/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [18/54]

void monolish::blas::matvec	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [19/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		vector< double > &	y
	)

Dense matrix and vector multiplication: y = Ax.

Parameters

A	Dense matrix (size M x N)
x	monolish vector (size M)
y	monolish vector (size M)

Note

• # of computation: MN
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

matvec() [20/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [21/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [22/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

matvec() [23/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [24/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [25/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

matvec() [26/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [27/54]

void monolish::blas::matvec	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [28/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		vector< float > &	y
	)

matvec() [29/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [30/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [31/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

matvec() [32/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [33/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [34/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

matvec() [35/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [36/54]

void monolish::blas::matvec	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [37/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		vector< double > &	y
	)

matrix (LinearOperator) and vector multiplication: y = Ax

Parameters

A	LinearOperator (size M x N)
x	monolish vector (size N)
y	monolish vector (size M)

Note

• # of computation: depends on matvec function
• Multi-threading: depends on matvec function
• GPU acceleration: depends on matvec function

matvec() [38/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [39/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [40/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

matvec() [41/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [42/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [43/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

matvec() [44/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

matvec() [45/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

matvec() [46/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		vector< float > &	y
	)

matvec() [47/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [48/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [49/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

matvec() [50/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [51/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

matvec() [52/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

matvec() [53/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

matvec() [54/54]

void monolish::blas::matvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

mscal() [1/4]

void monolish::blas::mscal	(	const double	alpha,
		matrix::CRS< double > &	A
	)

CRS matrix scal: A = alpha * A.

Parameters

alpha	scalar value
A	CRS matrix (size M x N)

Note

• # of computation: MN
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

mscal() [2/4]

void monolish::blas::mscal	(	const double	alpha,
		matrix::Dense< double > &	A
	)

Densematrix scal: A = alpha * A.

Parameters

alpha	scalar value
A	Dense matrix (size M x N)

Note

• # of computation: MN
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

mscal() [3/4]

void monolish::blas::mscal	(	const float	alpha,
		matrix::CRS< float > &	A
	)

mscal() [4/4]

void monolish::blas::mscal	(	const float	alpha,
		matrix::Dense< float > &	A
	)

nrm1() [1/12]

double monolish::blas::nrm1

(

const vector< double > &

x

)

nrm1: sum(abs(x[0:N]))

Parameters

x	monolish vector<float> (size N)

Returns

The result of the nrm1

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

nrm1() [2/12]

void monolish::blas::nrm1	(	const vector< double > &	x,
		double &	ans
	)

nrm1: sum(abs(x[0:N]))

Parameters

x	monolish vector<float> (size N)
ans	The result of the nrm1

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

nrm1() [3/12]

float monolish::blas::nrm1

(

const vector< float > &

x

)

nrm1() [4/12]

void monolish::blas::nrm1	(	const vector< float > &	x,
		float &	ans
	)

nrm1() [5/12]

double monolish::blas::nrm1

(

const view1D< matrix::Dense< double >, double > &

x

)

nrm1() [6/12]

void monolish::blas::nrm1	(	const view1D< matrix::Dense< double >, double > &	x,
		double &	ans
	)

nrm1() [7/12]

float monolish::blas::nrm1

(

const view1D< matrix::Dense< float >, float > &

x

)

nrm1() [8/12]

void monolish::blas::nrm1	(	const view1D< matrix::Dense< float >, float > &	x,
		float &	ans
	)

nrm1() [9/12]

double monolish::blas::nrm1

(

const view1D< vector< double >, double > &

x

)

nrm1() [10/12]

void monolish::blas::nrm1	(	const view1D< vector< double >, double > &	x,
		double &	ans
	)

nrm1() [11/12]

float monolish::blas::nrm1

(

const view1D< vector< float >, float > &

x

)

nrm1() [12/12]

void monolish::blas::nrm1	(	const view1D< vector< float >, float > &	x,
		float &	ans
	)

nrm2() [1/12]

double monolish::blas::nrm2

(

const vector< double > &

x

)

nrm2: ||x||_2

Parameters

x	monolish vector<float> (size N)

Returns

The result of the nrm2

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

nrm2() [2/12]

void monolish::blas::nrm2	(	const vector< double > &	x,
		double &	ans
	)

nrm2: ||x||_2

Parameters

x	monolish vector<float> (size N)
ans	The result of the nrm2

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

nrm2() [3/12]

float monolish::blas::nrm2

(

const vector< float > &

x

)

nrm2() [4/12]

void monolish::blas::nrm2	(	const vector< float > &	x,
		float &	ans
	)

nrm2() [5/12]

double monolish::blas::nrm2

(

const view1D< matrix::Dense< double >, double > &

x

)

nrm2() [6/12]

void monolish::blas::nrm2	(	const view1D< matrix::Dense< double >, double > &	x,
		double &	ans
	)

nrm2() [7/12]

float monolish::blas::nrm2

(

const view1D< matrix::Dense< float >, float > &

x

)

nrm2() [8/12]

void monolish::blas::nrm2	(	const view1D< matrix::Dense< float >, float > &	x,
		float &	ans
	)

nrm2() [9/12]

double monolish::blas::nrm2

(

const view1D< vector< double >, double > &

x

)

nrm2() [10/12]

void monolish::blas::nrm2	(	const view1D< vector< double >, double > &	x,
		double &	ans
	)

nrm2() [11/12]

float monolish::blas::nrm2

(

const view1D< vector< float >, float > &

x

)

nrm2() [12/12]

void monolish::blas::nrm2	(	const view1D< vector< float >, float > &	x,
		float &	ans
	)

rmatmul() [1/2]

void monolish::blas::rmatmul	(	const matrix::LinearOperator< double > &	A,
		const matrix::Dense< double > &	B,
		matrix::Dense< double > &	C
	)

LinearOperator multiplication: C = A^t B.

Parameters

A	LinearOperator (size K x M)
B	Dense matrix (size K x N)
C	Dense matrix (size M x N)

Note

• # of computation: ?
• Multi-threading: false
• GPU acceleration: false

rmatmul() [2/2]

void monolish::blas::rmatmul	(	const matrix::LinearOperator< float > &	A,
		const matrix::Dense< float > &	B,
		matrix::Dense< float > &	C
	)

rmatvec() [1/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		vector< double > &	y
	)

matrix (LinearOperator) and vector multiplication: y = Ax

Parameters

A	LinearOperator (size M x N)
x	monolish vector (size N)
y	monolish vector (size M)

Note

• # of computation: depends on matvec function
• Multi-threading: depends on matvec function
• GPU acceleration: depends on matvec function

rmatvec() [2/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

rmatvec() [3/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

rmatvec() [4/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

rmatvec() [5/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

rmatvec() [6/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

rmatvec() [7/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

rmatvec() [8/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

rmatvec() [9/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

rmatvec() [10/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		vector< float > &	y
	)

rmatvec() [11/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

rmatvec() [12/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

rmatvec() [13/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

rmatvec() [14/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

rmatvec() [15/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

rmatvec() [16/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

rmatvec() [17/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

rmatvec() [18/18]

void monolish::blas::rmatvec	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

scal() [1/6]

void monolish::blas::scal	(	const double	alpha,
		vector< double > &	x
	)

scal: x = alpha * x

Parameters

alpha	scalar value
x	monolish vector<float> (size N)

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

scal() [2/6]

void monolish::blas::scal	(	const double	alpha,
		view1D< matrix::Dense< double >, double > &	x
	)

scal() [3/6]

void monolish::blas::scal	(	const double	alpha,
		view1D< vector< double >, double > &	x
	)

scal() [4/6]

void monolish::blas::scal	(	const float	alpha,
		vector< float > &	x
	)

scal() [5/6]

void monolish::blas::scal	(	const float	alpha,
		view1D< matrix::Dense< float >, float > &	x
	)

scal() [6/6]

void monolish::blas::scal	(	const float	alpha,
		view1D< vector< float >, float > &	x
	)

sum() [1/12]

double monolish::blas::sum

(

const vector< double > &

x

)

vector<float> sum

Parameters

x	monolish vector<float> (size N)

Returns

The result of the sum

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

sum() [2/12]

void monolish::blas::sum	(	const vector< double > &	x,
		double &	ans
	)

vector<float> sum

Parameters

x	monolish vector<float> (size N)
ans	The result of the sum

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

sum() [3/12]

float monolish::blas::sum

(

const vector< float > &

x

)

sum() [4/12]

void monolish::blas::sum	(	const vector< float > &	x,
		float &	ans
	)

sum() [5/12]

double monolish::blas::sum

(

const view1D< matrix::Dense< double >, double > &

x

)

sum() [6/12]

void monolish::blas::sum	(	const view1D< matrix::Dense< double >, double > &	x,
		double &	ans
	)

sum() [7/12]

float monolish::blas::sum

(

const view1D< matrix::Dense< float >, float > &

x

)

sum() [8/12]

void monolish::blas::sum	(	const view1D< matrix::Dense< float >, float > &	x,
		float &	ans
	)

sum() [9/12]

double monolish::blas::sum

(

const view1D< vector< double >, double > &

x

)

sum() [10/12]

void monolish::blas::sum	(	const view1D< vector< double >, double > &	x,
		double &	ans
	)

sum() [11/12]

float monolish::blas::sum

(

const view1D< vector< float >, float > &

x

)

sum() [12/12]

void monolish::blas::sum	(	const view1D< vector< float >, float > &	x,
		float &	ans
	)

vecadd() [1/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

element by element addition of vector a and vector b.

Parameters

a	monolish vector (size N)
b	monolish vector (size N)
y	monolish vector (size N)

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

vecadd() [2/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [3/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [4/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [5/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [6/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [7/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [8/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [9/54]

void monolish::blas::vecadd	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [10/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecadd() [11/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [12/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [13/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [14/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [15/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [16/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [17/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [18/54]

void monolish::blas::vecadd	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [19/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

vecadd() [20/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [21/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [22/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [23/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [24/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [25/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [26/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [27/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [28/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecadd() [29/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [30/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [31/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [32/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [33/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [34/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [35/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [36/54]

void monolish::blas::vecadd	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [37/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

vecadd() [38/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [39/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [40/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [41/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [42/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [43/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecadd() [44/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecadd() [45/54]

void monolish::blas::vecadd	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecadd() [46/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecadd() [47/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [48/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [49/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [50/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [51/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecadd() [52/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecadd() [53/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecadd() [54/54]

void monolish::blas::vecadd	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [1/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

element by element subtract of vector a and vector b.

Parameters

a	monolish vector (size N)
b	monolish vector (size N)
y	monolish vector (size N)

Note

• # of computation: N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

vecsub() [2/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [3/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [4/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [5/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [6/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [7/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [8/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [9/54]

void monolish::blas::vecsub	(	const vector< double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [10/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecsub() [11/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [12/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [13/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [14/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [15/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [16/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [17/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [18/54]

void monolish::blas::vecsub	(	const vector< float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [19/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

vecsub() [20/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [21/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [22/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [23/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [24/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [25/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [26/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [27/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [28/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecsub() [29/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [30/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [31/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [32/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [33/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [34/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [35/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [36/54]

void monolish::blas::vecsub	(	const view1D< matrix::Dense< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [37/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

vecsub() [38/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [39/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const vector< double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [40/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [41/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [42/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< matrix::Dense< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [43/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		vector< double > &	y
	)

vecsub() [44/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< matrix::Dense< double >, double > &	y
	)

vecsub() [45/54]

void monolish::blas::vecsub	(	const view1D< vector< double >, double > &	a,
		const view1D< vector< double >, double > &	b,
		view1D< vector< double >, double > &	y
	)

vecsub() [46/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

vecsub() [47/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [48/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const vector< float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [49/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [50/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [51/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< matrix::Dense< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

vecsub() [52/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		vector< float > &	y
	)

vecsub() [53/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< matrix::Dense< float >, float > &	y
	)

vecsub() [54/54]

void monolish::blas::vecsub	(	const view1D< vector< float >, float > &	a,
		const view1D< vector< float >, float > &	b,
		view1D< vector< float >, float > &	y
	)

xpay() [1/18]

void monolish::blas::xpay	(	const double	alpha,
		const vector< double > &	x,
		vector< double > &	y
	)

xpay: y = x + ay

Parameters

alpha	scalar value
x	monolish vector<float> (size N)
y	monolish vector<float> (size N)

Note

• # of computation: 2N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

xpay() [2/18]

void monolish::blas::xpay	(	const double	alpha,
		const vector< double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

xpay() [3/18]

void monolish::blas::xpay	(	const double	alpha,
		const vector< double > &	x,
		view1D< vector< double >, double > &	y
	)

xpay() [4/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		vector< double > &	y
	)

xpay() [5/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

xpay() [6/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

xpay() [7/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		vector< double > &	y
	)

xpay() [8/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		view1D< matrix::Dense< double >, double > &	y
	)

xpay() [9/18]

void monolish::blas::xpay	(	const double	alpha,
		const view1D< vector< double >, double > &	x,
		view1D< vector< double >, double > &	y
	)

xpay() [10/18]

void monolish::blas::xpay	(	const float	alpha,
		const vector< float > &	x,
		vector< float > &	y
	)

xpay() [11/18]

void monolish::blas::xpay	(	const float	alpha,
		const vector< float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

xpay() [12/18]

void monolish::blas::xpay	(	const float	alpha,
		const vector< float > &	x,
		view1D< vector< float >, float > &	y
	)

xpay() [13/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		vector< float > &	y
	)

xpay() [14/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

xpay() [15/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)

xpay() [16/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		vector< float > &	y
	)

xpay() [17/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		view1D< matrix::Dense< float >, float > &	y
	)

xpay() [18/18]

void monolish::blas::xpay	(	const float	alpha,
		const view1D< vector< float >, float > &	x,
		view1D< vector< float >, float > &	y
	)