monolish::blas::times

element by element multiplication More...

Functions
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified col of dense matrix and vector adds: C[i][num] = A[i][num] + x[i]. More...
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[i]. More...
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const size_t num, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Specified col of tensor_Dense tensor and vector adds: C[i][num] = A[i][num] + x[i]. More...
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Column-wise tensor_Dense tensor and vector adds: ex. C[i][j] = A[i][j] + x[i]. More...
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< double > &A, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const size_t num, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_col (const tensor::tensor_Dense< float > &A, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified row of dense matrix and vector adds: C[num][j] = A[num][j] + x[j]. More...
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[j]. More...
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const size_t num, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Specified row of tensor_Dense tensor and vector adds: ex. C[num][j] = A[num][j] + x[j]. More...
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Row-wise tensor_Dense tensor and vector adds: ex. C[i][j] = A[i][j] + x[j]. More...
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< double > &A, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const size_t num, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::adds_row (const tensor::tensor_Dense< float > &A, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times (const double alpha, const matrix::CRS< double > &A, matrix::CRS< double > &C)
	CRS matrix times: C = alpha * A. More...
void	monolish::blas::times (const double alpha, const matrix::Dense< double > &A, matrix::Dense< double > &C)
	Dense matrix times: C = alpha * A. More...
void	monolish::blas::times (const double alpha, const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	tensor_Dense tensor times: C = alpha * A More...
void	monolish::blas::times (const double alpha, const vector< double > &a, vector< double > &y)
	element by element multiplication: y[i] = alpha * a[i] More...
void	monolish::blas::times (const double alpha, const vector< double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const vector< double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, vector< double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)
void	monolish::blas::times (const double alpha, const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, vector< double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const float alpha, const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	monolish::blas::times (const float alpha, const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	monolish::blas::times (const float alpha, const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)
void	monolish::blas::times (const float alpha, const vector< float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const vector< float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const vector< float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element multiplication: y[i] = a[i] * b[i] More...
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const vector< double > &x, matrix::CRS< double > &C)
	Specified col of CRS matrix and vector times: C[i][num] = A[i][num] * x[i]. More...
void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_col (const matrix::CRS< double > &A, const vector< double > &x, matrix::CRS< double > &C)
	Column-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[i]. More...
void	monolish::blas::times_col (const matrix::CRS< double > &A, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_col (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const vector< float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const vector< float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified col of dense matrix and vector times: C[i][num] = A[i][num] * x[i]. More...
void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Column-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[i]. More...
void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const size_t num, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Specified col of tensor_Dense tensor and vector times: C[i][num] = A[i][num] * x[i]. More...
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Column-wise tensor_Dense tensor and vector times: ex. C[i][j] = A[i][j] * x[i]. More...
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< double > &A, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const size_t num, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_col (const tensor::tensor_Dense< float > &A, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const vector< double > &x, matrix::CRS< double > &C)
	Specified row of CRS matrix and vector times: C[num][j] = A[num][j] * x[j]. More...
void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_row (const matrix::CRS< double > &A, const vector< double > &x, matrix::CRS< double > &C)
	Row-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[j]. More...
void	monolish::blas::times_row (const matrix::CRS< double > &A, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_row (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const vector< float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const vector< float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified row of dense matrix and vector times: C[num][j] = A[num][j] * x[j]. More...
void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[j]. More...
void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const size_t num, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Specified row of tensor_Dense tensor and vector times: ex. C[num][j] = A[num][j] * x[j]. More...
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const vector< double > &x, tensor::tensor_Dense< double > &C)
	Row-wise tensor_Dense tensor and vector times: ex. C[i][j] = A[i][j] * x[j]. More...
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< double > &A, const view1D< vector< double >, double > &x, tensor::tensor_Dense< double > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const size_t num, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const vector< float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, tensor::tensor_Dense< float > &C)
void	monolish::blas::times_row (const tensor::tensor_Dense< float > &A, const view1D< vector< float >, float > &x, tensor::tensor_Dense< float > &C)

Detailed Description

element by element multiplication

element by element addition

Function Documentation

adds_col() [1/32]

void monolish::blas::adds_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::Dense< double > &	C
	)

Specified col of dense matrix and vector adds: C[i][num] = A[i][num] + x[i].

Parameters

A	Dense matrix (size M x N)
num	col number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

adds_col() [2/32]

void monolish::blas::adds_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_col() [3/32]

void monolish::blas::adds_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_col() [4/32]

void monolish::blas::adds_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_col() [5/32]

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

Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[i].

Parameters

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

Note

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

adds_col() [6/32]

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

adds_col() [7/32]

void monolish::blas::adds_col	(	const matrix::Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_col() [8/32]

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

adds_col() [9/32]

void monolish::blas::adds_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::Dense< float > &	C
	)

adds_col() [10/32]

void monolish::blas::adds_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_col() [11/32]

void monolish::blas::adds_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_col() [12/32]

void monolish::blas::adds_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_col() [13/32]

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

adds_col() [14/32]

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

adds_col() [15/32]

void monolish::blas::adds_col	(	const matrix::Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_col() [16/32]

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

adds_col() [17/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Specified col of tensor_Dense tensor and vector adds: C[i][num] = A[i][num] + x[i].

Parameters

A	tensor_Dense tensor
num	column number
x	monolish vector (size M)
C	tensor_Dense tensor

Note

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

adds_col() [18/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [19/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [20/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [21/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Column-wise tensor_Dense tensor and vector adds: ex. C[i][j] = A[i][j] + x[i].

Parameters

A	tensor_Dense tensor
x	monolish vector
C	tensor_Dense tensor

Note

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

adds_col() [22/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [23/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [24/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_col() [25/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [26/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [27/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [28/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [29/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [30/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [31/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_col() [32/32]

void monolish::blas::adds_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [1/32]

void monolish::blas::adds_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::Dense< double > &	C
	)

Specified row of dense matrix and vector adds: C[num][j] = A[num][j] + x[j].

Parameters

A	Dense matrix (size M x N)
num	row number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

adds_row() [2/32]

void monolish::blas::adds_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_row() [3/32]

void monolish::blas::adds_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_row() [4/32]

void monolish::blas::adds_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_row() [5/32]

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

Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[j].

Parameters

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

Note

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

adds_row() [6/32]

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

adds_row() [7/32]

void monolish::blas::adds_row	(	const matrix::Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

adds_row() [8/32]

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

adds_row() [9/32]

void monolish::blas::adds_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::Dense< float > &	C
	)

adds_row() [10/32]

void monolish::blas::adds_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_row() [11/32]

void monolish::blas::adds_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_row() [12/32]

void monolish::blas::adds_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_row() [13/32]

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

adds_row() [14/32]

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

adds_row() [15/32]

void monolish::blas::adds_row	(	const matrix::Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

adds_row() [16/32]

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

adds_row() [17/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Specified row of tensor_Dense tensor and vector adds: ex. C[num][j] = A[num][j] + x[j].

Parameters

A	tensor_Dense tensor
num	row number (size N)
x	monolish vector
C	tensor_Dense tensor

Note

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

adds_row() [18/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [19/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [20/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [21/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Row-wise tensor_Dense tensor and vector adds: ex. C[i][j] = A[i][j] + x[j].

Parameters

A	tensor_Dense tensor
x	monolish vector
C	tensor_Dense tensor

Note

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

adds_row() [22/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [23/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [24/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

adds_row() [25/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [26/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [27/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [28/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [29/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [30/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [31/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

adds_row() [32/32]

void monolish::blas::adds_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times() [1/166]

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

CRS matrix times: C = alpha * A.

Parameters

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

Note

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

Warning

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

times() [2/166]

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

Dense matrix times: C = alpha * A.

Parameters

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

Note

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

times() [3/166]

void monolish::blas::times	(	const double	alpha,
		const tensor::tensor_Dense< double > &	A,
		tensor::tensor_Dense< double > &	C
	)

tensor_Dense tensor times: C = alpha * A

Parameters

alpha	scalar value
A	tensor_Dense tensor
C	tensor_Dense tensor

Note

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

times() [4/166]

void monolish::blas::times	(	const double	alpha,
		const vector< double > &	a,
		vector< double > &	y
	)

element by element multiplication: y[i] = alpha * a[i]

Parameters

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

Note

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

times() [5/166]

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

times() [6/166]

void monolish::blas::times	(	const double	alpha,
		const vector< double > &	a,
		view1D< tensor::tensor_Dense< double >, double > &	y
	)

times() [7/166]

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

times() [8/166]

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

times() [9/166]

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

times() [10/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< matrix::Dense< double >, double > &	a,
		view1D< tensor::tensor_Dense< double >, double > &	y
	)

times() [11/166]

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

times() [12/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< tensor::tensor_Dense< double >, double > &	a,
		vector< double > &	y
	)

times() [13/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< tensor::tensor_Dense< double >, double > &	a,
		view1D< matrix::Dense< double >, double > &	y
	)

times() [14/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< tensor::tensor_Dense< double >, double > &	a,
		view1D< tensor::tensor_Dense< double >, double > &	y
	)

times() [15/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< tensor::tensor_Dense< double >, double > &	a,
		view1D< vector< double >, double > &	y
	)

times() [16/166]

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

times() [17/166]

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

times() [18/166]

void monolish::blas::times	(	const double	alpha,
		const view1D< vector< double >, double > &	a,
		view1D< tensor::tensor_Dense< double >, double > &	y
	)

times() [19/166]

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

times() [20/166]

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

times() [21/166]

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

times() [22/166]

void monolish::blas::times	(	const float	alpha,
		const tensor::tensor_Dense< float > &	A,
		tensor::tensor_Dense< float > &	C
	)

times() [23/166]

void monolish::blas::times	(	const float	alpha,
		const vector< float > &	a,
		vector< float > &	y
	)

times() [24/166]

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

times() [25/166]

void monolish::blas::times	(	const float	alpha,
		const vector< float > &	a,
		view1D< tensor::tensor_Dense< float >, float > &	y
	)

times() [26/166]

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

times() [27/166]

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

times() [28/166]

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

times() [29/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< matrix::Dense< float >, float > &	a,
		view1D< tensor::tensor_Dense< float >, float > &	y
	)

times() [30/166]

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

times() [31/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< tensor::tensor_Dense< float >, float > &	a,
		vector< float > &	y
	)

times() [32/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< tensor::tensor_Dense< float >, float > &	a,
		view1D< matrix::Dense< float >, float > &	y
	)

times() [33/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< tensor::tensor_Dense< float >, float > &	a,
		view1D< tensor::tensor_Dense< float >, float > &	y
	)

times() [34/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< tensor::tensor_Dense< float >, float > &	a,
		view1D< vector< float >, float > &	y
	)

times() [35/166]

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

times() [36/166]

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

times() [37/166]

void monolish::blas::times	(	const float	alpha,
		const view1D< vector< float >, float > &	a,
		view1D< tensor::tensor_Dense< float >, float > &	y
	)

times() [38/166]

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

times() [39/166]

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

element by element multiplication: y[i] = a[i] * b[i]

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

times() [40/166]

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

times() [41/166]

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

times() [42/166]

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

times() [43/166]

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

times() [44/166]

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

times() [45/166]

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

times() [46/166]

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

times() [47/166]

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

times() [48/166]

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

times() [49/166]

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

times() [50/166]

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

times() [51/166]

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

times() [52/166]

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

times() [53/166]

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

times() [54/166]

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

times() [55/166]

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

times() [56/166]

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

times() [57/166]

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

times() [58/166]

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

times() [59/166]

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

times() [60/166]

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

times() [61/166]

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

times() [62/166]

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

times() [63/166]

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

times() [64/166]

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

times() [65/166]

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

times() [66/166]

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

times() [67/166]

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

times() [68/166]

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

times() [69/166]

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

times() [70/166]

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

times() [71/166]

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

times() [72/166]

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

times() [73/166]

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

times() [74/166]

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

times() [75/166]

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

times() [76/166]

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

times() [77/166]

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

times() [78/166]

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

times() [79/166]

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

times() [80/166]

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

times() [81/166]

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

times() [82/166]

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

times() [83/166]

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

times() [84/166]

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

times() [85/166]

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

times() [86/166]

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

times() [87/166]

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

times() [88/166]

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

times() [89/166]

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

times() [90/166]

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

times() [91/166]

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

times() [92/166]

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

times() [93/166]

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

times() [94/166]

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

times() [95/166]

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

times() [96/166]

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

times() [97/166]

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

times() [98/166]

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

times() [99/166]

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

times() [100/166]

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

times() [101/166]

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

times() [102/166]

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

times() [103/166]

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

times() [104/166]

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

times() [105/166]

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

times() [106/166]

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

times() [107/166]

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

times() [108/166]

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

times() [109/166]

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

times() [110/166]

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

times() [111/166]

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

times() [112/166]

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

times() [113/166]

void monolish::blas::times	(	const view1D< tensor::tensor_Dense< double >, double > &	a,
		const view1D< tensor::tensor_Dense< double >, double > &	b,
		view1D< tensor::tensor_Dense< double >, double > &	y
	)

times() [114/166]

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

times() [115/166]

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

times() [116/166]

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

times() [117/166]

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

times() [118/166]

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

times() [119/166]

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

times() [120/166]

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

times() [121/166]

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

times() [122/166]

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

times() [123/166]

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

times() [124/166]

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

times() [125/166]

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

times() [126/166]

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

times() [127/166]

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

times() [128/166]

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

times() [129/166]

void monolish::blas::times	(	const view1D< tensor::tensor_Dense< float >, float > &	a,
		const view1D< tensor::tensor_Dense< float >, float > &	b,
		view1D< tensor::tensor_Dense< float >, float > &	y
	)

times() [130/166]

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

times() [131/166]

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

times() [132/166]

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

times() [133/166]

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

times() [134/166]

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

times() [135/166]

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

times() [136/166]

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

times() [137/166]

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

times() [138/166]

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

times() [139/166]

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

times() [140/166]

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

times() [141/166]

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

times() [142/166]

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

times() [143/166]

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

times() [144/166]

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

times() [145/166]

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

times() [146/166]

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

times() [147/166]

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

times() [148/166]

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

times() [149/166]

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

times() [150/166]

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

times() [151/166]

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

times() [152/166]

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

times() [153/166]

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

times() [154/166]

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

times() [155/166]

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

times() [156/166]

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

times() [157/166]

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

times() [158/166]

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

times() [159/166]

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

times() [160/166]

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

times() [161/166]

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

times() [162/166]

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

times() [163/166]

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

times() [164/166]

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

times() [165/166]

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

times() [166/166]

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

times_col() [1/44]

void monolish::blas::times_col	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::CRS< double > &	C
	)

Specified col of CRS matrix and vector times: C[i][num] = A[i][num] * x[i].

Parameters

A	CRS matrix (size M x N)
num	column number
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

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

Warning

A and C must be same non-zero structure

times_col() [2/44]

void monolish::blas::times_col	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const view1D< matrix::CRS< double >, double > &	x,
		matrix::CRS< double > &	C
	)

times_col() [3/44]

void monolish::blas::times_col	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::CRS< double > &	C
	)

times_col() [4/44]

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

Column-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[i].

Parameters

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

Note

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

Warning

A and C must be same non-zero structure

times_col() [5/44]

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

times_col() [6/44]

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

times_col() [7/44]

void monolish::blas::times_col	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::CRS< float > &	C
	)

times_col() [8/44]

void monolish::blas::times_col	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const view1D< matrix::CRS< float >, float > &	x,
		matrix::CRS< float > &	C
	)

times_col() [9/44]

void monolish::blas::times_col	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::CRS< float > &	C
	)

times_col() [10/44]

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

times_col() [11/44]

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

times_col() [12/44]

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

times_col() [13/44]

void monolish::blas::times_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::Dense< double > &	C
	)

Specified col of dense matrix and vector times: C[i][num] = A[i][num] * x[i].

Parameters

A	Dense matrix (size M x N)
num	column number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

times_col() [14/44]

void monolish::blas::times_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_col() [15/44]

void monolish::blas::times_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_col() [16/44]

void monolish::blas::times_col	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_col() [17/44]

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

Column-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[i].

Parameters

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

Note

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

times_col() [18/44]

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

times_col() [19/44]

void monolish::blas::times_col	(	const matrix::Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_col() [20/44]

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

times_col() [21/44]

void monolish::blas::times_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::Dense< float > &	C
	)

times_col() [22/44]

void monolish::blas::times_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_col() [23/44]

void monolish::blas::times_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_col() [24/44]

void monolish::blas::times_col	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_col() [25/44]

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

times_col() [26/44]

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

times_col() [27/44]

void monolish::blas::times_col	(	const matrix::Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_col() [28/44]

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

times_col() [29/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Specified col of tensor_Dense tensor and vector times: C[i][num] = A[i][num] * x[i].

Parameters

A	tensor_Dense tensor
num	column number
x	monolish vector (size M)
C	tensor_Dense tensor

Note

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

times_col() [30/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [31/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [32/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [33/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Column-wise tensor_Dense tensor and vector times: ex. C[i][j] = A[i][j] * x[i].

Parameters

A	tensor_Dense tensor
x	monolish vector
C	tensor_Dense tensor

Note

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

times_col() [34/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [35/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [36/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_col() [37/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [38/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [39/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [40/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [41/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [42/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [43/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_col() [44/44]

void monolish::blas::times_col	(	const tensor::tensor_Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [1/44]

void monolish::blas::times_row	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::CRS< double > &	C
	)

Specified row of CRS matrix and vector times: C[num][j] = A[num][j] * x[j].

Parameters

A	CRS matrix (size M x N)
num	row number
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

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

Warning

A and C must be same non-zero structure

times_row() [2/44]

void monolish::blas::times_row	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const view1D< matrix::CRS< double >, double > &	x,
		matrix::CRS< double > &	C
	)

times_row() [3/44]

void monolish::blas::times_row	(	const matrix::CRS< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::CRS< double > &	C
	)

times_row() [4/44]

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

Row-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[j].

Parameters

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

Note

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

Warning

A and C must be same non-zero structure

times_row() [5/44]

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

times_row() [6/44]

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

times_row() [7/44]

void monolish::blas::times_row	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::CRS< float > &	C
	)

times_row() [8/44]

void monolish::blas::times_row	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const view1D< matrix::CRS< float >, float > &	x,
		matrix::CRS< float > &	C
	)

times_row() [9/44]

void monolish::blas::times_row	(	const matrix::CRS< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::CRS< float > &	C
	)

times_row() [10/44]

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

times_row() [11/44]

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

times_row() [12/44]

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

times_row() [13/44]

void monolish::blas::times_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		matrix::Dense< double > &	C
	)

Specified row of dense matrix and vector times: C[num][j] = A[num][j] * x[j].

Parameters

A	Dense matrix (size M x N)
num	row number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

times_row() [14/44]

void monolish::blas::times_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_row() [15/44]

void monolish::blas::times_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_row() [16/44]

void monolish::blas::times_row	(	const matrix::Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_row() [17/44]

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

Row-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[j].

Parameters

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

Note

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

times_row() [18/44]

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

times_row() [19/44]

void monolish::blas::times_row	(	const matrix::Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		matrix::Dense< double > &	C
	)

times_row() [20/44]

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

times_row() [21/44]

void monolish::blas::times_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		matrix::Dense< float > &	C
	)

times_row() [22/44]

void monolish::blas::times_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_row() [23/44]

void monolish::blas::times_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_row() [24/44]

void monolish::blas::times_row	(	const matrix::Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_row() [25/44]

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

times_row() [26/44]

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

times_row() [27/44]

void monolish::blas::times_row	(	const matrix::Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		matrix::Dense< float > &	C
	)

times_row() [28/44]

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

times_row() [29/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Specified row of tensor_Dense tensor and vector times: ex. C[num][j] = A[num][j] * x[j].

Parameters

A	tensor_Dense tensor
num	row number (size N)
x	monolish vector
C	tensor_Dense tensor

Note

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

times_row() [30/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [31/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [32/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const size_t	num,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [33/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const vector< double > &	x,
		tensor::tensor_Dense< double > &	C
	)

Row-wise tensor_Dense tensor and vector times: ex. C[i][j] = A[i][j] * x[j].

Parameters

A	tensor_Dense tensor
x	monolish vector
C	tensor_Dense tensor

Note

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

times_row() [34/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [35/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< tensor::tensor_Dense< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [36/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		tensor::tensor_Dense< double > &	C
	)

times_row() [37/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [38/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [39/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [40/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const size_t	num,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [41/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const vector< float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [42/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [43/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< tensor::tensor_Dense< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)

times_row() [44/44]

void monolish::blas::times_row	(	const tensor::tensor_Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		tensor::tensor_Dense< float > &	C
	)