monolish::vml Namespace Reference

Vector and Matrix element-wise math library. More...

Functions
void	add (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element addition CRS matrix A and CRS matrix B. More...
void	add (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element addition CRS matrix A and CRS matrix B. More...
void	add (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)
void	add (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	add (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element addition Dense matrix A and Dense matrix B. More...
void	add (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element addition Dense matrix A and Dense matrix B. More...
void	add (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)
void	add (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	add (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element addition LinearOperator matrix A and LinearOperator matrix B. More...
void	add (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	element by element addition LinearOperator matrix A and LinearOperator matrix B. More...
void	add (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)
void	add (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)
void	add (const vector< double > &a, const double alpha, vector< double > &y)
	element by element addition of vector a and vector b. More...
void	add (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)
void	add (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element addition of vector a and vector b. More...
void	add (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	add (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	add (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	add (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const vector< float > &a, const float alpha, vector< float > &y)
void	add (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)
void	add (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	add (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	add (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	add (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	add (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	add (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)
void	add (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	add (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	add (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	add (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)
void	add (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	add (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	add (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	asin (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	asin to CRS matrix elements (C[0:nnz] = asin(A[0:nnz])) More...
void	asin (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	asin (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	asin to Dense matrix elements (C[0:nnz] = asin(A[0:nnz])) More...
void	asin (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	asin (const vector< double > &a, vector< double > &y)
	asin to vector elements (y[0:N] = asin(a[0:N])) More...
void	asin (const vector< double > &a, view1D< vector< double >, double > &y)
void	asin (const vector< float > &a, vector< float > &y)
void	asin (const vector< float > &a, view1D< vector< float >, float > &y)
void	asin (const view1D< vector< double >, double > &a, vector< double > &y)
void	asin (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	asin (const view1D< vector< float >, float > &a, vector< float > &y)
void	asin (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	asinh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	asinh to CRS matrix elements (C[0:nnz] = asinh(A[0:nnz])) More...
void	asinh (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	asinh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	asinh to Dense matrix elements (C[0:nnz] = asinh(A[0:nnz])) More...
void	asinh (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	asinh (const vector< double > &a, vector< double > &y)
	asinh to vector elements (y[0:N] = asinh(a[0:N])) More...
void	asinh (const vector< double > &a, view1D< vector< double >, double > &y)
void	asinh (const vector< float > &a, vector< float > &y)
void	asinh (const vector< float > &a, view1D< vector< float >, float > &y)
void	asinh (const view1D< vector< double >, double > &a, vector< double > &y)
void	asinh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	asinh (const view1D< vector< float >, float > &a, vector< float > &y)
void	asinh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	atan (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	atan to CRS matrix elements (C[0:nnz] = atan(A[0:nnz])) More...
void	atan (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	atan (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	atan to Dense matrix elements (C[0:nnz] = atan(A[0:nnz])) More...
void	atan (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	atan (const vector< double > &a, vector< double > &y)
	atan to vector elements (y[0:N] = atan(a[0:N])) More...
void	atan (const vector< double > &a, view1D< vector< double >, double > &y)
void	atan (const vector< float > &a, vector< float > &y)
void	atan (const vector< float > &a, view1D< vector< float >, float > &y)
void	atan (const view1D< vector< double >, double > &a, vector< double > &y)
void	atan (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	atan (const view1D< vector< float >, float > &a, vector< float > &y)
void	atan (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	atanh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	atanh to CRS matrix elements (C[0:nnz] = atanh(A[0:nnz])) More...
void	atanh (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	atanh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	atanh to Dense matrix elements (C[0:nnz] = atanh(A[0:nnz])) More...
void	atanh (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	atanh (const vector< double > &a, vector< double > &y)
	atanh to vector elements (y[0:N] = atanh(a[0:N])) More...
void	atanh (const vector< double > &a, view1D< vector< double >, double > &y)
void	atanh (const vector< float > &a, vector< float > &y)
void	atanh (const vector< float > &a, view1D< vector< float >, float > &y)
void	atanh (const view1D< vector< double >, double > &a, vector< double > &y)
void	atanh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	atanh (const view1D< vector< float >, float > &a, vector< float > &y)
void	atanh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	ceil (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	ceil to CRS matrix elements (C[0:nnz] = ceil(A[0:nnz])) More...
void	ceil (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	ceil (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	ceil to Dense matrix elements (C[0:nnz] = ceil(A[0:nnz])) More...
void	ceil (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	ceil (const vector< double > &a, vector< double > &y)
	ceil to vector elements (y[0:N] = ceil(a[0:N])) More...
void	ceil (const vector< double > &a, view1D< vector< double >, double > &y)
void	ceil (const vector< float > &a, vector< float > &y)
void	ceil (const vector< float > &a, view1D< vector< float >, float > &y)
void	ceil (const view1D< vector< double >, double > &a, vector< double > &y)
void	ceil (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	ceil (const view1D< vector< float >, float > &a, vector< float > &y)
void	ceil (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	div (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element division CRS matrix A and CRS matrix B. More...
void	div (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element division CRS matrix A and CRS matrix B. More...
void	div (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)
void	div (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	div (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element division Dense matrix A and Dense matrix B. More...
void	div (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element division Dense matrix A and Dense matrix B. More...
void	div (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)
void	div (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	div (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element division LinearOperator matrix A and LinearOperator matrix B. More...
void	div (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)
void	div (const vector< double > &a, const double alpha, vector< double > &y)
	element by element division of vector a and vector b. More...
void	div (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)
void	div (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element division of vector a and vector b. More...
void	div (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	div (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	div (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	div (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const vector< float > &a, const float alpha, vector< float > &y)
void	div (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)
void	div (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	div (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	div (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	div (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	div (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	div (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)
void	div (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	div (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	div (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	div (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)
void	div (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	div (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	div (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	floor (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	floor to CRS matrix elements (C[0:nnz] = floor(A[0:nnz])) More...
void	floor (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	floor (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	floor to Dense matrix elements (C[0:nnz] = floor(A[0:nnz])) More...
void	floor (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	floor (const vector< double > &a, vector< double > &y)
	floor to vector elements (y[0:N] = floor(a[0:N])) More...
void	floor (const vector< double > &a, view1D< vector< double >, double > &y)
void	floor (const vector< float > &a, vector< float > &y)
void	floor (const vector< float > &a, view1D< vector< float >, float > &y)
void	floor (const view1D< vector< double >, double > &a, vector< double > &y)
void	floor (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	floor (const view1D< vector< float >, float > &a, vector< float > &y)
void	floor (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	max (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	Create a new CRS matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...
double	max (const matrix::CRS< double > &C)
	Finds the greatest element in CRS matrix (max(C[0:nnz])) More...
void	max (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
float	max (const matrix::CRS< float > &C)
void	max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...
double	max (const matrix::Dense< double > &C)
	Finds the greatest element in Dense matrix (max(C[0:nnz])) More...
void	max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
float	max (const matrix::Dense< float > &C)
void	max (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with greatest elements of two matrices (y[0:N] = max(a[0:N], b[0:N])) More...
void	max (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	max (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	max (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
double	max (const vector< double > &y)
	Finds the greatest element in vector (max(y[0:N])) More...
void	max (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	max (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	max (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	max (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
float	max (const vector< float > &y)
double	max (const view1D< matrix::Dense< double >, double > &y)
float	max (const view1D< matrix::Dense< float >, float > &y)
void	max (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	max (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
double	max (const view1D< vector< double >, double > &y)
void	max (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	max (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
float	max (const view1D< vector< float >, float > &y)
void	min (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	Create a new CRS matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz])) More...
double	min (const matrix::CRS< double > &C)
	Finds the smallest element in CRS matrix (min(C[0:nnz])) More...
void	min (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
float	min (const matrix::CRS< float > &C)
void	min (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Create a new Dense matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz])) More...
double	min (const matrix::Dense< double > &C)
	Finds the smallest element in Dense matrix (min(C[0:nnz])) More...
void	min (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
float	min (const matrix::Dense< float > &C)
void	min (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with smallest elements of two matrices (y[0:N] = min(a[0:N], b[0:N])) More...
void	min (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	min (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	min (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
double	min (const vector< double > &y)
	Finds the smallest element in vector (min(y[0:N])) More...
void	min (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	min (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	min (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	min (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
float	min (const vector< float > &y)
double	min (const view1D< matrix::Dense< double >, double > &y)
float	min (const view1D< matrix::Dense< float >, float > &y)
void	min (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	min (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
double	min (const view1D< vector< double >, double > &y)
void	min (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	min (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
float	min (const view1D< vector< float >, float > &y)
void	mul (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element multiplication CRS matrix A and CRS matrix B. More...
void	mul (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element multiplication CRS matrix A and CRS matrix B. More...
void	mul (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)
void	mul (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	mul (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element multiplication Dense matrix A and Dense matrix B. More...
void	mul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element multiplication Dense matrix A and Dense matrix B. More...
void	mul (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)
void	mul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	mul (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element multiplication LinearOperator matrix A and LinearOperator matrix B. More...
void	mul (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)
void	mul (const vector< double > &a, const double alpha, vector< double > &y)
	element by element multiplication of vector a and vector b. More...
void	mul (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)
void	mul (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element multiplication of vector a and vector b. More...
void	mul (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const vector< float > &a, const float alpha, vector< float > &y)
void	mul (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)
void	mul (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	mul (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)
void	mul (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	mul (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)
void	mul (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	pow (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	power to CRS matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha)) More...
void	pow (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	power to CRS matrix elements CRS matrix (C[0:N] = pow(A[0:N], B[0:N])) More...
void	pow (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)
void	pow (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	pow (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	power to Dense matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha)) More...
void	pow (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	power to Dense matrix elements Dense matrix (C[0:N] = pow(A[0:N], B[0:N])) More...
void	pow (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)
void	pow (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	pow (const vector< double > &a, const double alpha, vector< double > &y)
	power to vector elements by double precision scalar value (y[0:N] = pow(a[0:N], alpha)) More...
void	pow (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)
void	pow (const vector< double > &a, const vector< double > &b, vector< double > &y)
	power to vector elements by double precision vector (y[0:N] = pow(a[0:N], b[0]:N])) More...
void	pow (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	pow (const vector< float > &a, const float alpha, vector< float > &y)
void	pow (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)
void	pow (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	pow (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	pow (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)
void	pow (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)
void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	pow (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)
void	pow (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)
void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	reciprocal (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	reciprocal to CRS matrix elements (C[0:nnz] = 1 / A[0:nnz]) More...
void	reciprocal (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	reciprocal (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	reciprocal to Dense matrix elements (C[0:nnz] = 1 / A[0:nnz]) More...
void	reciprocal (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	reciprocal (const vector< double > &a, vector< double > &y)
	reciprocal to double precision vector elements (y[0:N] = 1 / a[0:N]) More...
void	reciprocal (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)
void	reciprocal (const vector< double > &a, view1D< vector< double >, double > &y)
void	reciprocal (const vector< float > &a, vector< float > &y)
void	reciprocal (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)
void	reciprocal (const vector< float > &a, view1D< vector< float >, float > &y)
void	reciprocal (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)
void	reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)
void	reciprocal (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)
void	reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)
void	reciprocal (const view1D< vector< double >, double > &a, vector< double > &y)
void	reciprocal (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	reciprocal (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	reciprocal (const view1D< vector< float >, float > &a, vector< float > &y)
void	reciprocal (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	reciprocal (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	sign (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sign to CRS matrix elements (C[0:nnz] = sign(A[0:nnz])) More...
void	sign (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	sign (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sign to Dense matrix elements (C[0:nnz] = sign(A[0:nnz])) More...
void	sign (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	sign (const vector< double > &a, vector< double > &y)
	sign to vector elements (y[0:N] = sign(a[0:N])) More...
void	sign (const vector< double > &a, view1D< vector< double >, double > &y)
void	sign (const vector< float > &a, vector< float > &y)
void	sign (const vector< float > &a, view1D< vector< float >, float > &y)
void	sign (const view1D< vector< double >, double > &a, vector< double > &y)
void	sign (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	sign (const view1D< vector< float >, float > &a, vector< float > &y)
void	sign (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	sin (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sin to CRS matrix elements (C[0:nnz] = sin(A[0:nnz])) More...
void	sin (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	sin (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sin to Dense matrix elements (C[0:nnz] = sin(A[0:nnz])) More...
void	sin (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	sin (const vector< double > &a, vector< double > &y)
	sin to vector elements (y[0:N] = sin(a[0:N])) More...
void	sin (const vector< double > &a, view1D< vector< double >, double > &y)
void	sin (const vector< float > &a, vector< float > &y)
void	sin (const vector< float > &a, view1D< vector< float >, float > &y)
void	sin (const view1D< vector< double >, double > &a, vector< double > &y)
void	sin (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	sin (const view1D< vector< float >, float > &a, vector< float > &y)
void	sin (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	sinh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sinh to CRS matrix elements (C[0:nnz] = sinh(A[0:nnz])) More...
void	sinh (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	sinh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sinh to Dense matrix elements (C[0:nnz] = sinh(A[0:nnz])) More...
void	sinh (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	sinh (const vector< double > &a, vector< double > &y)
	sinh to vector elements (y[0:N] = sinh(a[0:N])) More...
void	sinh (const vector< double > &a, view1D< vector< double >, double > &y)
void	sinh (const vector< float > &a, vector< float > &y)
void	sinh (const vector< float > &a, view1D< vector< float >, float > &y)
void	sinh (const view1D< vector< double >, double > &a, vector< double > &y)
void	sinh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	sinh (const view1D< vector< float >, float > &a, vector< float > &y)
void	sinh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	sqrt (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sqrt to CRS matrix elements (C[0:nnz] = sqrt(A[0:nnz])) More...
void	sqrt (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	sqrt (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sqrt to Dense matrix elements (C[0:nnz] = sqrt(A[0:nnz])) More...
void	sqrt (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	sqrt (const vector< double > &a, vector< double > &y)
	sqrt to vector elements (y[0:N] = sqrt(a[0:N])) More...
void	sqrt (const vector< double > &a, view1D< vector< double >, double > &y)
void	sqrt (const vector< float > &a, vector< float > &y)
void	sqrt (const vector< float > &a, view1D< vector< float >, float > &y)
void	sqrt (const view1D< vector< double >, double > &a, vector< double > &y)
void	sqrt (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	sqrt (const view1D< vector< float >, float > &a, vector< float > &y)
void	sqrt (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	sub (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element subtract CRS matrix A and CRS matrix B. More...
void	sub (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element subtract CRS matrix A and CRS matrix B. More...
void	sub (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)
void	sub (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)
void	sub (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element subtract Dense matrix A and Dense matrix B. More...
void	sub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element subtract Dense matrix A and Dense matrix B. More...
void	sub (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)
void	sub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	sub (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element subtract LinearOperator matrix A and LinearOperator matrix B. More...
void	sub (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	element by element subtract LinearOperator matrix A and LinearOperator matrix B. More...
void	sub (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)
void	sub (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)
void	sub (const vector< double > &a, const double alpha, vector< double > &y)
	element by element subtract of vector a and vector b. More...
void	sub (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)
void	sub (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element subtract of vector a and vector b. More...
void	sub (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const vector< float > &a, const float alpha, vector< float > &y)
void	sub (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)
void	sub (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	sub (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)
void	sub (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	sub (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)
void	sub (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	tan (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	tan to CRS matrix elements (C[0:nnz] = tan(A[0:nnz])) More...
void	tan (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	tan (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	tan to Dense matrix elements (C[0:nnz] = tan(A[0:nnz])) More...
void	tan (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	tan (const vector< double > &a, vector< double > &y)
	tan to vector elements (y[0:N] = tan(a[0:N])) More...
void	tan (const vector< double > &a, view1D< vector< double >, double > &y)
void	tan (const vector< float > &a, vector< float > &y)
void	tan (const vector< float > &a, view1D< vector< float >, float > &y)
void	tan (const view1D< vector< double >, double > &a, vector< double > &y)
void	tan (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	tan (const view1D< vector< float >, float > &a, vector< float > &y)
void	tan (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	tanh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	tanh to CRS matrix elements (C[0:nnz] = tanh(A[0:nnz])) More...
void	tanh (const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	tanh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	tanh to Dense matrix elements (C[0:nnz] = tanh(A[0:nnz])) More...
void	tanh (const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	tanh (const vector< double > &a, vector< double > &y)
	tanh to vector elements (y[0:N] = tanh(a[0:N])) More...
void	tanh (const vector< double > &a, view1D< vector< double >, double > &y)
void	tanh (const vector< float > &a, vector< float > &y)
void	tanh (const vector< float > &a, view1D< vector< float >, float > &y)
void	tanh (const view1D< vector< double >, double > &a, vector< double > &y)
void	tanh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	tanh (const view1D< vector< float >, float > &a, vector< float > &y)
void	tanh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

Detailed Description

Vector and Matrix element-wise math library.

Function Documentation

add() [1/74]

void monolish::vml::add	(	const matrix::CRS< double > &	A,
		const double	alpha,
		matrix::CRS< double > &	C
	)

element by element addition CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
alpha	scalar value
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

add() [2/74]

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

element by element addition CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
B	monolish CRS Matrix (size M x N)
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

add() [3/74]

void monolish::vml::add	(	const matrix::CRS< float > &	A,
		const float	alpha,
		matrix::CRS< float > &	C
	)

add() [4/74]

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

add() [5/74]

void monolish::vml::add	(	const matrix::Dense< double > &	A,
		const double	alpha,
		matrix::Dense< double > &	C
	)

element by element addition Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
alpha	scalar value
C	monolish Dense Matrix (size M x N)

Note

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

add() [6/74]

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

element by element addition Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
B	monolish Dense Matrix (size M x N)
C	monolish Dense Matrix (size M x N)

Note

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

add() [7/74]

void monolish::vml::add	(	const matrix::Dense< float > &	A,
		const float	alpha,
		matrix::Dense< float > &	C
	)

add() [8/74]

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

add() [9/74]

void monolish::vml::add	(	const matrix::LinearOperator< double > &	A,
		const double &	alpha,
		matrix::LinearOperator< double > &	C
	)

element by element addition LinearOperator matrix A and LinearOperator matrix B.

Parameters

A	monolish LinearOperator Matrix (size M x N)
alpha	scalar value
C	monolish LinearOperator Matrix (size M x N)

Note

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

add() [10/74]

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

element by element addition LinearOperator matrix A and LinearOperator matrix B.

Parameters

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

Note

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

add() [11/74]

void monolish::vml::add	(	const matrix::LinearOperator< float > &	A,
		const float &	alpha,
		matrix::LinearOperator< float > &	C
	)

add() [12/74]

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

add() [13/74]

void monolish::vml::add	(	const vector< double > &	a,
		const double	alpha,
		vector< double > &	y
	)

element by element addition of vector a and vector b.

Parameters

a	monolish vector (size N)
alpha	scalar value
y	monolish vector (size N)

Note

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

add() [14/74]

void monolish::vml::add	(	const vector< double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

add() [15/74]

void monolish::vml::add	(	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

add() [16/74]

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

add() [17/74]

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

add() [18/74]

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

add() [19/74]

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

add() [20/74]

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

add() [21/74]

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

add() [22/74]

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

add() [23/74]

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

add() [24/74]

void monolish::vml::add	(	const vector< float > &	a,
		const float	alpha,
		vector< float > &	y
	)

add() [25/74]

void monolish::vml::add	(	const vector< float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

add() [26/74]

void monolish::vml::add	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

add() [27/74]

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

add() [28/74]

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

add() [29/74]

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

add() [30/74]

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

add() [31/74]

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

add() [32/74]

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

add() [33/74]

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

add() [34/74]

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

add() [35/74]

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

add() [36/74]

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

add() [37/74]

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

add() [38/74]

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

add() [39/74]

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

add() [40/74]

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

add() [41/74]

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

add() [42/74]

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

add() [43/74]

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

add() [44/74]

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

add() [45/74]

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

add() [46/74]

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

add() [47/74]

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

add() [48/74]

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

add() [49/74]

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

add() [50/74]

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

add() [51/74]

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

add() [52/74]

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

add() [53/74]

void monolish::vml::add	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		vector< double > &	y
	)

add() [54/74]

void monolish::vml::add	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

add() [55/74]

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

add() [56/74]

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

add() [57/74]

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

add() [58/74]

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

add() [59/74]

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

add() [60/74]

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

add() [61/74]

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

add() [62/74]

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

add() [63/74]

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

add() [64/74]

void monolish::vml::add	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		vector< float > &	y
	)

add() [65/74]

void monolish::vml::add	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

add() [66/74]

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

add() [67/74]

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

add() [68/74]

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

add() [69/74]

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

add() [70/74]

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

add() [71/74]

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

add() [72/74]

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

add() [73/74]

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

add() [74/74]

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

asin() [1/12]

void monolish::vml::asin	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

asin to CRS matrix elements (C[0:nnz] = asin(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

asin() [2/12]

void monolish::vml::asin	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

asin() [3/12]

void monolish::vml::asin	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

asin to Dense matrix elements (C[0:nnz] = asin(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

asin() [4/12]

void monolish::vml::asin	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

asin() [5/12]

void monolish::vml::asin	(	const vector< double > &	a,
		vector< double > &	y
	)

asin to vector elements (y[0:N] = asin(a[0:N]))

Parameters

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

Note

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

asin() [6/12]

void monolish::vml::asin	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

asin() [7/12]

void monolish::vml::asin	(	const vector< float > &	a,
		vector< float > &	y
	)

asin() [8/12]

void monolish::vml::asin	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

asin() [9/12]

void monolish::vml::asin	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

asin() [10/12]

void monolish::vml::asin	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

asin() [11/12]

void monolish::vml::asin	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

asin() [12/12]

void monolish::vml::asin	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

asinh() [1/12]

void monolish::vml::asinh	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

asinh to CRS matrix elements (C[0:nnz] = asinh(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

asinh() [2/12]

void monolish::vml::asinh	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

asinh() [3/12]

void monolish::vml::asinh	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

asinh to Dense matrix elements (C[0:nnz] = asinh(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

asinh() [4/12]

void monolish::vml::asinh	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

asinh() [5/12]

void monolish::vml::asinh	(	const vector< double > &	a,
		vector< double > &	y
	)

asinh to vector elements (y[0:N] = asinh(a[0:N]))

Parameters

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

Note

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

asinh() [6/12]

void monolish::vml::asinh	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

asinh() [7/12]

void monolish::vml::asinh	(	const vector< float > &	a,
		vector< float > &	y
	)

asinh() [8/12]

void monolish::vml::asinh	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

asinh() [9/12]

void monolish::vml::asinh	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

asinh() [10/12]

void monolish::vml::asinh	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

asinh() [11/12]

void monolish::vml::asinh	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

asinh() [12/12]

void monolish::vml::asinh	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

atan() [1/12]

void monolish::vml::atan	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

atan to CRS matrix elements (C[0:nnz] = atan(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

atan() [2/12]

void monolish::vml::atan	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

atan() [3/12]

void monolish::vml::atan	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

atan to Dense matrix elements (C[0:nnz] = atan(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

atan() [4/12]

void monolish::vml::atan	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

atan() [5/12]

void monolish::vml::atan	(	const vector< double > &	a,
		vector< double > &	y
	)

atan to vector elements (y[0:N] = atan(a[0:N]))

Parameters

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

Note

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

atan() [6/12]

void monolish::vml::atan	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

atan() [7/12]

void monolish::vml::atan	(	const vector< float > &	a,
		vector< float > &	y
	)

atan() [8/12]

void monolish::vml::atan	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

atan() [9/12]

void monolish::vml::atan	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

atan() [10/12]

void monolish::vml::atan	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

atan() [11/12]

void monolish::vml::atan	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

atan() [12/12]

void monolish::vml::atan	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

atanh() [1/12]

void monolish::vml::atanh	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

atanh to CRS matrix elements (C[0:nnz] = atanh(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

atanh() [2/12]

void monolish::vml::atanh	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

atanh() [3/12]

void monolish::vml::atanh	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

atanh to Dense matrix elements (C[0:nnz] = atanh(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

atanh() [4/12]

void monolish::vml::atanh	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

atanh() [5/12]

void monolish::vml::atanh	(	const vector< double > &	a,
		vector< double > &	y
	)

atanh to vector elements (y[0:N] = atanh(a[0:N]))

Parameters

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

Note

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

atanh() [6/12]

void monolish::vml::atanh	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

atanh() [7/12]

void monolish::vml::atanh	(	const vector< float > &	a,
		vector< float > &	y
	)

atanh() [8/12]

void monolish::vml::atanh	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

atanh() [9/12]

void monolish::vml::atanh	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

atanh() [10/12]

void monolish::vml::atanh	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

atanh() [11/12]

void monolish::vml::atanh	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

atanh() [12/12]

void monolish::vml::atanh	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

ceil() [1/12]

void monolish::vml::ceil	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

ceil to CRS matrix elements (C[0:nnz] = ceil(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

ceil() [2/12]

void monolish::vml::ceil	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

ceil() [3/12]

void monolish::vml::ceil	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

ceil to Dense matrix elements (C[0:nnz] = ceil(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

ceil() [4/12]

void monolish::vml::ceil	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

ceil() [5/12]

void monolish::vml::ceil	(	const vector< double > &	a,
		vector< double > &	y
	)

ceil to vector elements (y[0:N] = ceil(a[0:N]))

Parameters

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

Note

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

ceil() [6/12]

void monolish::vml::ceil	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

ceil() [7/12]

void monolish::vml::ceil	(	const vector< float > &	a,
		vector< float > &	y
	)

ceil() [8/12]

void monolish::vml::ceil	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

ceil() [9/12]

void monolish::vml::ceil	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

ceil() [10/12]

void monolish::vml::ceil	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

ceil() [11/12]

void monolish::vml::ceil	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

ceil() [12/12]

void monolish::vml::ceil	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

div() [1/72]

void monolish::vml::div	(	const matrix::CRS< double > &	A,
		const double	alpha,
		matrix::CRS< double > &	C
	)

element by element division CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
alpha	scalar value
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

div() [2/72]

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

element by element division CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
B	monolish CRS Matrix (size M x N)
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

div() [3/72]

void monolish::vml::div	(	const matrix::CRS< float > &	A,
		const float	alpha,
		matrix::CRS< float > &	C
	)

div() [4/72]

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

div() [5/72]

void monolish::vml::div	(	const matrix::Dense< double > &	A,
		const double	alpha,
		matrix::Dense< double > &	C
	)

element by element division Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
alpha	scalar value
C	monolish Dense Matrix (size M x N)

Note

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

div() [6/72]

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

element by element division Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
B	monolish Dense Matrix (size M x N)
C	monolish Dense Matrix (size M x N)

Note

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

div() [7/72]

void monolish::vml::div	(	const matrix::Dense< float > &	A,
		const float	alpha,
		matrix::Dense< float > &	C
	)

div() [8/72]

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

div() [9/72]

void monolish::vml::div	(	const matrix::LinearOperator< double > &	A,
		const double &	alpha,
		matrix::LinearOperator< double > &	C
	)

element by element division LinearOperator matrix A and LinearOperator matrix B.

Parameters

A	monolish LinearOperator Matrix (size M x N)
alpha	scalar value
C	monolish LinearOperator Matrix (size M x N)

Note

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

div() [10/72]

void monolish::vml::div	(	const matrix::LinearOperator< float > &	A,
		const float &	alpha,
		matrix::LinearOperator< float > &	C
	)

div() [11/72]

void monolish::vml::div	(	const vector< double > &	a,
		const double	alpha,
		vector< double > &	y
	)

element by element division of vector a and vector b.

Parameters

a	monolish vector (size N)
alpha	scalar value
y	monolish vector (size N)

Note

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

div() [12/72]

void monolish::vml::div	(	const vector< double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

div() [13/72]

void monolish::vml::div	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

element by element division 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

div() [14/72]

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

div() [15/72]

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

div() [16/72]

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

div() [17/72]

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

div() [18/72]

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

div() [19/72]

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

div() [20/72]

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

div() [21/72]

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

div() [22/72]

void monolish::vml::div	(	const vector< float > &	a,
		const float	alpha,
		vector< float > &	y
	)

div() [23/72]

void monolish::vml::div	(	const vector< float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

div() [24/72]

void monolish::vml::div	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

div() [25/72]

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

div() [26/72]

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

div() [27/72]

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

div() [28/72]

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

div() [29/72]

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

div() [30/72]

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

div() [31/72]

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

div() [32/72]

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

div() [33/72]

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

div() [34/72]

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

div() [35/72]

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

div() [36/72]

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

div() [37/72]

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

div() [38/72]

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

div() [39/72]

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

div() [40/72]

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

div() [41/72]

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

div() [42/72]

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

div() [43/72]

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

div() [44/72]

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

div() [45/72]

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

div() [46/72]

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

div() [47/72]

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

div() [48/72]

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

div() [49/72]

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

div() [50/72]

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

div() [51/72]

void monolish::vml::div	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		vector< double > &	y
	)

div() [52/72]

void monolish::vml::div	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

div() [53/72]

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

div() [54/72]

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

div() [55/72]

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

div() [56/72]

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

div() [57/72]

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

div() [58/72]

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

div() [59/72]

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

div() [60/72]

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

div() [61/72]

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

div() [62/72]

void monolish::vml::div	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		vector< float > &	y
	)

div() [63/72]

void monolish::vml::div	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

div() [64/72]

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

div() [65/72]

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

div() [66/72]

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

div() [67/72]

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

div() [68/72]

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

div() [69/72]

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

div() [70/72]

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

div() [71/72]

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

div() [72/72]

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

floor() [1/12]

void monolish::vml::floor	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

floor to CRS matrix elements (C[0:nnz] = floor(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

floor() [2/12]

void monolish::vml::floor	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

floor() [3/12]

void monolish::vml::floor	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

floor to Dense matrix elements (C[0:nnz] = floor(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

floor() [4/12]

void monolish::vml::floor	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

floor() [5/12]

void monolish::vml::floor	(	const vector< double > &	a,
		vector< double > &	y
	)

floor to vector elements (y[0:N] = floor(a[0:N]))

Parameters

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

Note

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

floor() [6/12]

void monolish::vml::floor	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

floor() [7/12]

void monolish::vml::floor	(	const vector< float > &	a,
		vector< float > &	y
	)

floor() [8/12]

void monolish::vml::floor	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

floor() [9/12]

void monolish::vml::floor	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

floor() [10/12]

void monolish::vml::floor	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

floor() [11/12]

void monolish::vml::floor	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

floor() [12/12]

void monolish::vml::floor	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

max() [1/30]

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

Create a new CRS matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

Here is the caller graph for this function:

max() [2/30]

double monolish::vml::max

(

const matrix::CRS< double > &

C

)

Finds the greatest element in CRS matrix (max(C[0:nnz]))

Parameters

C	monolish CRS matrix (size M x N)

Returns

greatest value

Note

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

Warning

A, B, and C must be same non-zero structure

max() [3/30]

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

max() [4/30]

float monolish::vml::max

(

const matrix::CRS< float > &

C

)

max() [5/30]

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

Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Parameters

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

Note

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

max() [6/30]

double monolish::vml::max

(

const matrix::Dense< double > &

C

)

Finds the greatest element in Dense matrix (max(C[0:nnz]))

Parameters

C	monolish Dense matrix (size M x N)

Returns

greatest value

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

max() [7/30]

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

max() [8/30]

float monolish::vml::max

(

const matrix::Dense< float > &

C

)

max() [9/30]

void monolish::vml::max	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

Create a new vector with greatest elements of two matrices (y[0:N] = max(a[0:N], b[0:N]))

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

max() [10/30]

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

max() [11/30]

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

max() [12/30]

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

max() [13/30]

double monolish::vml::max

(

const vector< double > &

y

)

Finds the greatest element in vector (max(y[0:N]))

Parameters

y	monolish vector (size N)

Returns

greatest value

Note

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

max() [14/30]

void monolish::vml::max	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

max() [15/30]

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

max() [16/30]

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

max() [17/30]

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

max() [18/30]

float monolish::vml::max

(

const vector< float > &

y

)

max() [19/30]

double monolish::vml::max

(

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

y

)

max() [20/30]

float monolish::vml::max

(

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

y

)

max() [21/30]

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

max() [22/30]

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

max() [23/30]

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

max() [24/30]

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

max() [25/30]

double monolish::vml::max

(

const view1D< vector< double >, double > &

y

)

max() [26/30]

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

max() [27/30]

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

max() [28/30]

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

max() [29/30]

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

max() [30/30]

float monolish::vml::max

(

const view1D< vector< float >, float > &

y

)

min() [1/30]

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

Create a new CRS matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

Here is the caller graph for this function:

min() [2/30]

double monolish::vml::min

(

const matrix::CRS< double > &

C

)

Finds the smallest element in CRS matrix (min(C[0:nnz]))

Parameters

C	monolish CRS matrix (size M x N)

Returns

smallest value

Note

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

Warning

A, B, and C must be same non-zero structure

min() [3/30]

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

min() [4/30]

float monolish::vml::min

(

const matrix::CRS< float > &

C

)

min() [5/30]

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

Create a new Dense matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz]))

Parameters

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

Note

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

min() [6/30]

double monolish::vml::min

(

const matrix::Dense< double > &

C

)

Finds the smallest element in Dense matrix (min(C[0:nnz]))

Parameters

C	monolish Dense matrix (size M x N)

Returns

smallest value

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

min() [7/30]

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

min() [8/30]

float monolish::vml::min

(

const matrix::Dense< float > &

C

)

min() [9/30]

void monolish::vml::min	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

Create a new vector with smallest elements of two matrices (y[0:N] = min(a[0:N], b[0:N]))

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

min() [10/30]

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

min() [11/30]

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

min() [12/30]

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

min() [13/30]

double monolish::vml::min

(

const vector< double > &

y

)

Finds the smallest element in vector (min(y[0:N]))

Parameters

y	monolish vector (size N)

Returns

smallest value

Note

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

min() [14/30]

void monolish::vml::min	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

min() [15/30]

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

min() [16/30]

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

min() [17/30]

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

min() [18/30]

float monolish::vml::min

(

const vector< float > &

y

)

min() [19/30]

double monolish::vml::min

(

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

y

)

min() [20/30]

float monolish::vml::min

(

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

y

)

min() [21/30]

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

min() [22/30]

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

min() [23/30]

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

min() [24/30]

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

min() [25/30]

double monolish::vml::min

(

const view1D< vector< double >, double > &

y

)

min() [26/30]

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

min() [27/30]

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

min() [28/30]

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

min() [29/30]

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

min() [30/30]

float monolish::vml::min

(

const view1D< vector< float >, float > &

y

)

mul() [1/72]

void monolish::vml::mul	(	const matrix::CRS< double > &	A,
		const double	alpha,
		matrix::CRS< double > &	C
	)

element by element multiplication CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
alpha	scalar value
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

mul() [2/72]

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

element by element multiplication CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
B	monolish CRS Matrix (size M x N)
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

mul() [3/72]

void monolish::vml::mul	(	const matrix::CRS< float > &	A,
		const float	alpha,
		matrix::CRS< float > &	C
	)

mul() [4/72]

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

mul() [5/72]

void monolish::vml::mul	(	const matrix::Dense< double > &	A,
		const double	alpha,
		matrix::Dense< double > &	C
	)

element by element multiplication Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
alpha	scalar value
C	monolish Dense Matrix (size M x N)

Note

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

mul() [6/72]

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

element by element multiplication Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
B	monolish Dense Matrix (size M x N)
C	monolish Dense Matrix (size M x N)

Note

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

mul() [7/72]

void monolish::vml::mul	(	const matrix::Dense< float > &	A,
		const float	alpha,
		matrix::Dense< float > &	C
	)

mul() [8/72]

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

mul() [9/72]

void monolish::vml::mul	(	const matrix::LinearOperator< double > &	A,
		const double &	alpha,
		matrix::LinearOperator< double > &	C
	)

element by element multiplication LinearOperator matrix A and LinearOperator matrix B.

Parameters

A	monolish LinearOperator Matrix (size M x N)
alpha	scalar value
C	monolish LinearOperator Matrix (size M x N)

Note

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

mul() [10/72]

void monolish::vml::mul	(	const matrix::LinearOperator< float > &	A,
		const float &	alpha,
		matrix::LinearOperator< float > &	C
	)

mul() [11/72]

void monolish::vml::mul	(	const vector< double > &	a,
		const double	alpha,
		vector< double > &	y
	)

element by element multiplication of vector a and vector b.

Parameters

a	monolish vector (size N)
alpha	scalar value
y	monolish vector (size N)

Note

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

mul() [12/72]

void monolish::vml::mul	(	const vector< double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

mul() [13/72]

void monolish::vml::mul	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

element by element multiplication 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

mul() [14/72]

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

mul() [15/72]

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

mul() [16/72]

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

mul() [17/72]

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

mul() [18/72]

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

mul() [19/72]

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

mul() [20/72]

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

mul() [21/72]

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

mul() [22/72]

void monolish::vml::mul	(	const vector< float > &	a,
		const float	alpha,
		vector< float > &	y
	)

mul() [23/72]

void monolish::vml::mul	(	const vector< float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

mul() [24/72]

void monolish::vml::mul	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

mul() [25/72]

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

mul() [26/72]

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

mul() [27/72]

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

mul() [28/72]

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

mul() [29/72]

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

mul() [30/72]

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

mul() [31/72]

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

mul() [32/72]

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

mul() [33/72]

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

mul() [34/72]

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

mul() [35/72]

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

mul() [36/72]

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

mul() [37/72]

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

mul() [38/72]

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

mul() [39/72]

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

mul() [40/72]

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

mul() [41/72]

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

mul() [42/72]

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

mul() [43/72]

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

mul() [44/72]

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

mul() [45/72]

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

mul() [46/72]

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

mul() [47/72]

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

mul() [48/72]

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

mul() [49/72]

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

mul() [50/72]

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

mul() [51/72]

void monolish::vml::mul	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		vector< double > &	y
	)

mul() [52/72]

void monolish::vml::mul	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

mul() [53/72]

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

mul() [54/72]

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

mul() [55/72]

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

mul() [56/72]

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

mul() [57/72]

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

mul() [58/72]

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

mul() [59/72]

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

mul() [60/72]

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

mul() [61/72]

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

mul() [62/72]

void monolish::vml::mul	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		vector< float > &	y
	)

mul() [63/72]

void monolish::vml::mul	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

mul() [64/72]

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

mul() [65/72]

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

mul() [66/72]

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

mul() [67/72]

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

mul() [68/72]

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

mul() [69/72]

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

mul() [70/72]

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

mul() [71/72]

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

mul() [72/72]

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

pow() [1/32]

void monolish::vml::pow	(	const matrix::CRS< double > &	A,
		const double	alpha,
		matrix::CRS< double > &	C
	)

power to CRS matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha))

Parameters

A	monolish CRS Matrix (size M x N)
alpha	scalar value
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

pow() [2/32]

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

power to CRS matrix elements CRS matrix (C[0:N] = pow(A[0:N], B[0:N]))

Parameters

A	monolish CRS Matrix (size M x N)
B	monolish CRS Matrix (size M x N)
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

pow() [3/32]

void monolish::vml::pow	(	const matrix::CRS< float > &	A,
		const float	alpha,
		matrix::CRS< float > &	C
	)

pow() [4/32]

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

pow() [5/32]

void monolish::vml::pow	(	const matrix::Dense< double > &	A,
		const double	alpha,
		matrix::Dense< double > &	C
	)

power to Dense matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha))

Parameters

A	monolish Dense Matrix (size M x N)
alpha	scalar value
C	monolish Dense Matrix (size M x N)

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

pow() [6/32]

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

power to Dense matrix elements Dense matrix (C[0:N] = pow(A[0:N], B[0:N]))

Parameters

A	monolish Dense Matrix (size M x N)
B	monolish Dense Matrix (size M x N)
C	monolish Dense Matrix (size M x N)

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

pow() [7/32]

void monolish::vml::pow	(	const matrix::Dense< float > &	A,
		const float	alpha,
		matrix::Dense< float > &	C
	)

pow() [8/32]

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

pow() [9/32]

void monolish::vml::pow	(	const vector< double > &	a,
		const double	alpha,
		vector< double > &	y
	)

power to vector elements by double precision scalar value (y[0:N] = pow(a[0:N], alpha))

Parameters

a	monolish vector (size N)
alpha	scalar value
y	monolish vector (size N)

Note

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

pow() [10/32]

void monolish::vml::pow	(	const vector< double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

pow() [11/32]

void monolish::vml::pow	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

power to vector elements by double precision vector (y[0:N] = pow(a[0:N], b[0]:N]))

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

pow() [12/32]

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

pow() [13/32]

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

pow() [14/32]

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

pow() [15/32]

void monolish::vml::pow	(	const vector< float > &	a,
		const float	alpha,
		vector< float > &	y
	)

pow() [16/32]

void monolish::vml::pow	(	const vector< float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

pow() [17/32]

void monolish::vml::pow	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

pow() [18/32]

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

pow() [19/32]

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

pow() [20/32]

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

pow() [21/32]

void monolish::vml::pow	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		vector< double > &	y
	)

pow() [22/32]

void monolish::vml::pow	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

pow() [23/32]

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

pow() [24/32]

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

pow() [25/32]

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

pow() [26/32]

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

pow() [27/32]

void monolish::vml::pow	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		vector< float > &	y
	)

pow() [28/32]

void monolish::vml::pow	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

pow() [29/32]

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

pow() [30/32]

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

pow() [31/32]

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

pow() [32/32]

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

reciprocal() [1/22]

void monolish::vml::reciprocal	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

reciprocal to CRS matrix elements (C[0:nnz] = 1 / A[0:nnz])

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

reciprocal() [2/22]

void monolish::vml::reciprocal	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

reciprocal() [3/22]

void monolish::vml::reciprocal	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

reciprocal to Dense matrix elements (C[0:nnz] = 1 / A[0:nnz])

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

reciprocal() [4/22]

void monolish::vml::reciprocal	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

reciprocal() [5/22]

void monolish::vml::reciprocal	(	const vector< double > &	a,
		vector< double > &	y
	)

reciprocal to double precision vector elements (y[0:N] = 1 / a[0:N])

Parameters

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

Note

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

reciprocal() [6/22]

void monolish::vml::reciprocal	(	const vector< double > &	a,
		view1D< matrix::Dense< double >, double > &	y
	)

reciprocal() [7/22]

void monolish::vml::reciprocal	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

reciprocal() [8/22]

void monolish::vml::reciprocal	(	const vector< float > &	a,
		vector< float > &	y
	)

reciprocal() [9/22]

void monolish::vml::reciprocal	(	const vector< float > &	a,
		view1D< matrix::Dense< float >, float > &	y
	)

reciprocal() [10/22]

void monolish::vml::reciprocal	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

reciprocal() [11/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< double >, double > &	a,
		vector< double > &	y
	)

reciprocal() [12/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< double >, double > &	a,
		view1D< matrix::Dense< double >, double > &	y
	)

reciprocal() [13/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

reciprocal() [14/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< float >, float > &	a,
		vector< float > &	y
	)

reciprocal() [15/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< float >, float > &	a,
		view1D< matrix::Dense< float >, float > &	y
	)

reciprocal() [16/22]

void monolish::vml::reciprocal	(	const view1D< matrix::Dense< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

reciprocal() [17/22]

void monolish::vml::reciprocal	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

reciprocal() [18/22]

void monolish::vml::reciprocal	(	const view1D< vector< double >, double > &	a,
		view1D< matrix::Dense< double >, double > &	y
	)

reciprocal() [19/22]

void monolish::vml::reciprocal	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

reciprocal() [20/22]

void monolish::vml::reciprocal	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

reciprocal() [21/22]

void monolish::vml::reciprocal	(	const view1D< vector< float >, float > &	a,
		view1D< matrix::Dense< float >, float > &	y
	)

reciprocal() [22/22]

void monolish::vml::reciprocal	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

sign() [1/12]

void monolish::vml::sign	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

sign to CRS matrix elements (C[0:nnz] = sign(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

sign() [2/12]

void monolish::vml::sign	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

sign() [3/12]

void monolish::vml::sign	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

sign to Dense matrix elements (C[0:nnz] = sign(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

sign() [4/12]

void monolish::vml::sign	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

sign() [5/12]

void monolish::vml::sign	(	const vector< double > &	a,
		vector< double > &	y
	)

sign to vector elements (y[0:N] = sign(a[0:N]))

Parameters

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

Note

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

sign() [6/12]

void monolish::vml::sign	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

sign() [7/12]

void monolish::vml::sign	(	const vector< float > &	a,
		vector< float > &	y
	)

sign() [8/12]

void monolish::vml::sign	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

sign() [9/12]

void monolish::vml::sign	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

sign() [10/12]

void monolish::vml::sign	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

sign() [11/12]

void monolish::vml::sign	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

sign() [12/12]

void monolish::vml::sign	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

sin() [1/12]

void monolish::vml::sin	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

sin to CRS matrix elements (C[0:nnz] = sin(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

sin() [2/12]

void monolish::vml::sin	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

sin() [3/12]

void monolish::vml::sin	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

sin to Dense matrix elements (C[0:nnz] = sin(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

sin() [4/12]

void monolish::vml::sin	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

sin() [5/12]

void monolish::vml::sin	(	const vector< double > &	a,
		vector< double > &	y
	)

sin to vector elements (y[0:N] = sin(a[0:N]))

Parameters

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

Note

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

sin() [6/12]

void monolish::vml::sin	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

sin() [7/12]

void monolish::vml::sin	(	const vector< float > &	a,
		vector< float > &	y
	)

sin() [8/12]

void monolish::vml::sin	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

sin() [9/12]

void monolish::vml::sin	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

sin() [10/12]

void monolish::vml::sin	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

sin() [11/12]

void monolish::vml::sin	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

sin() [12/12]

void monolish::vml::sin	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

sinh() [1/12]

void monolish::vml::sinh	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

sinh to CRS matrix elements (C[0:nnz] = sinh(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

sinh() [2/12]

void monolish::vml::sinh	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

sinh() [3/12]

void monolish::vml::sinh	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

sinh to Dense matrix elements (C[0:nnz] = sinh(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

sinh() [4/12]

void monolish::vml::sinh	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

sinh() [5/12]

void monolish::vml::sinh	(	const vector< double > &	a,
		vector< double > &	y
	)

sinh to vector elements (y[0:N] = sinh(a[0:N]))

Parameters

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

Note

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

sinh() [6/12]

void monolish::vml::sinh	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

sinh() [7/12]

void monolish::vml::sinh	(	const vector< float > &	a,
		vector< float > &	y
	)

sinh() [8/12]

void monolish::vml::sinh	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

sinh() [9/12]

void monolish::vml::sinh	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

sinh() [10/12]

void monolish::vml::sinh	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

sinh() [11/12]

void monolish::vml::sinh	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

sinh() [12/12]

void monolish::vml::sinh	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

sqrt() [1/12]

void monolish::vml::sqrt	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

sqrt to CRS matrix elements (C[0:nnz] = sqrt(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

sqrt() [2/12]

void monolish::vml::sqrt	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

sqrt() [3/12]

void monolish::vml::sqrt	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

sqrt to Dense matrix elements (C[0:nnz] = sqrt(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

sqrt() [4/12]

void monolish::vml::sqrt	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

sqrt() [5/12]

void monolish::vml::sqrt	(	const vector< double > &	a,
		vector< double > &	y
	)

sqrt to vector elements (y[0:N] = sqrt(a[0:N]))

Parameters

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

Note

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

sqrt() [6/12]

void monolish::vml::sqrt	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

sqrt() [7/12]

void monolish::vml::sqrt	(	const vector< float > &	a,
		vector< float > &	y
	)

sqrt() [8/12]

void monolish::vml::sqrt	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

sqrt() [9/12]

void monolish::vml::sqrt	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

sqrt() [10/12]

void monolish::vml::sqrt	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

sqrt() [11/12]

void monolish::vml::sqrt	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

sqrt() [12/12]

void monolish::vml::sqrt	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

sub() [1/74]

void monolish::vml::sub	(	const matrix::CRS< double > &	A,
		const double	alpha,
		matrix::CRS< double > &	C
	)

element by element subtract CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
alpha	scalar value
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

sub() [2/74]

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

element by element subtract CRS matrix A and CRS matrix B.

Parameters

A	monolish CRS Matrix (size M x N)
B	monolish CRS Matrix (size M x N)
C	monolish CRS Matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

sub() [3/74]

void monolish::vml::sub	(	const matrix::CRS< float > &	A,
		const float	alpha,
		matrix::CRS< float > &	C
	)

sub() [4/74]

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

sub() [5/74]

void monolish::vml::sub	(	const matrix::Dense< double > &	A,
		const double	alpha,
		matrix::Dense< double > &	C
	)

element by element subtract Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
alpha	scalar value
C	monolish Dense Matrix (size M x N)

Note

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

sub() [6/74]

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

element by element subtract Dense matrix A and Dense matrix B.

Parameters

A	monolish Dense Matrix (size M x N)
B	monolish Dense Matrix (size M x N)
C	monolish Dense Matrix (size M x N)

Note

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

sub() [7/74]

void monolish::vml::sub	(	const matrix::Dense< float > &	A,
		const float	alpha,
		matrix::Dense< float > &	C
	)

sub() [8/74]

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

sub() [9/74]

void monolish::vml::sub	(	const matrix::LinearOperator< double > &	A,
		const double &	alpha,
		matrix::LinearOperator< double > &	C
	)

element by element subtract LinearOperator matrix A and LinearOperator matrix B.

Parameters

A	monolish LinearOperator Matrix (size M x N)
alpha	scalar value
C	monolish LinearOperator Matrix (size M x N)

Note

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

sub() [10/74]

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

element by element subtract LinearOperator matrix A and LinearOperator matrix B.

Parameters

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

Note

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

sub() [11/74]

void monolish::vml::sub	(	const matrix::LinearOperator< float > &	A,
		const float &	alpha,
		matrix::LinearOperator< float > &	C
	)

sub() [12/74]

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

sub() [13/74]

void monolish::vml::sub	(	const vector< double > &	a,
		const double	alpha,
		vector< double > &	y
	)

element by element subtract of vector a and vector b.

Parameters

a	monolish vector (size N)
alpha	scalar value
y	monolish vector (size N)

Note

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

sub() [14/74]

void monolish::vml::sub	(	const vector< double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

sub() [15/74]

void monolish::vml::sub	(	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

sub() [16/74]

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

sub() [17/74]

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

sub() [18/74]

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

sub() [19/74]

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

sub() [20/74]

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

sub() [21/74]

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

sub() [22/74]

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

sub() [23/74]

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

sub() [24/74]

void monolish::vml::sub	(	const vector< float > &	a,
		const float	alpha,
		vector< float > &	y
	)

sub() [25/74]

void monolish::vml::sub	(	const vector< float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

sub() [26/74]

void monolish::vml::sub	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

sub() [27/74]

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

sub() [28/74]

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

sub() [29/74]

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

sub() [30/74]

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

sub() [31/74]

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

sub() [32/74]

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

sub() [33/74]

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

sub() [34/74]

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

sub() [35/74]

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

sub() [36/74]

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

sub() [37/74]

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

sub() [38/74]

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

sub() [39/74]

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

sub() [40/74]

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

sub() [41/74]

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

sub() [42/74]

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

sub() [43/74]

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

sub() [44/74]

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

sub() [45/74]

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

sub() [46/74]

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

sub() [47/74]

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

sub() [48/74]

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

sub() [49/74]

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

sub() [50/74]

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

sub() [51/74]

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

sub() [52/74]

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

sub() [53/74]

void monolish::vml::sub	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		vector< double > &	y
	)

sub() [54/74]

void monolish::vml::sub	(	const view1D< vector< double >, double > &	a,
		const double	alpha,
		view1D< vector< double >, double > &	y
	)

sub() [55/74]

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

sub() [56/74]

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

sub() [57/74]

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

sub() [58/74]

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

sub() [59/74]

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

sub() [60/74]

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

sub() [61/74]

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

sub() [62/74]

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

sub() [63/74]

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

sub() [64/74]

void monolish::vml::sub	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		vector< float > &	y
	)

sub() [65/74]

void monolish::vml::sub	(	const view1D< vector< float >, float > &	a,
		const float	alpha,
		view1D< vector< float >, float > &	y
	)

sub() [66/74]

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

sub() [67/74]

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

sub() [68/74]

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

sub() [69/74]

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

sub() [70/74]

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

sub() [71/74]

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

sub() [72/74]

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

sub() [73/74]

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

sub() [74/74]

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

tan() [1/12]

void monolish::vml::tan	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

tan to CRS matrix elements (C[0:nnz] = tan(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

tan() [2/12]

void monolish::vml::tan	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

tan() [3/12]

void monolish::vml::tan	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

tan to Dense matrix elements (C[0:nnz] = tan(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

tan() [4/12]

void monolish::vml::tan	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

tan() [5/12]

void monolish::vml::tan	(	const vector< double > &	a,
		vector< double > &	y
	)

tan to vector elements (y[0:N] = tan(a[0:N]))

Parameters

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

Note

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

tan() [6/12]

void monolish::vml::tan	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

tan() [7/12]

void monolish::vml::tan	(	const vector< float > &	a,
		vector< float > &	y
	)

tan() [8/12]

void monolish::vml::tan	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

tan() [9/12]

void monolish::vml::tan	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

tan() [10/12]

void monolish::vml::tan	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

tan() [11/12]

void monolish::vml::tan	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

tan() [12/12]

void monolish::vml::tan	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

tanh() [1/12]

void monolish::vml::tanh	(	const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

tanh to CRS matrix elements (C[0:nnz] = tanh(A[0:nnz]))

Parameters

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

Note

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

Warning

A, B, and C must be same non-zero structure

tanh() [2/12]

void monolish::vml::tanh	(	const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

tanh() [3/12]

void monolish::vml::tanh	(	const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

tanh to Dense matrix elements (C[0:nnz] = tanh(A[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true

tanh() [4/12]

void monolish::vml::tanh	(	const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

tanh() [5/12]

void monolish::vml::tanh	(	const vector< double > &	a,
		vector< double > &	y
	)

tanh to vector elements (y[0:N] = tanh(a[0:N]))

Parameters

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

Note

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

tanh() [6/12]

void monolish::vml::tanh	(	const vector< double > &	a,
		view1D< vector< double >, double > &	y
	)

tanh() [7/12]

void monolish::vml::tanh	(	const vector< float > &	a,
		vector< float > &	y
	)

tanh() [8/12]

void monolish::vml::tanh	(	const vector< float > &	a,
		view1D< vector< float >, float > &	y
	)

tanh() [9/12]

void monolish::vml::tanh	(	const view1D< vector< double >, double > &	a,
		vector< double > &	y
	)

tanh() [10/12]

void monolish::vml::tanh	(	const view1D< vector< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

tanh() [11/12]

void monolish::vml::tanh	(	const view1D< vector< float >, float > &	a,
		vector< float > &	y
	)

tanh() [12/12]

void monolish::vml::tanh	(	const view1D< vector< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)