monolish::blas::matmul (Dense, Dense, Dense)

Dense matrix multiplication: C = AB. More...

Functions
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const matrix::Dense< double > &B, const double &b, matrix::Dense< double > &C)
	Dense matrix multiplication: C = aAB+bC. More...
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, matrix::Dense< double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const double &a, const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, const double &b, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const matrix::Dense< float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, matrix::Dense< float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const float &a, const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, const float &b, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Dense matrix multiplication: C = AB. More...
void	monolish::blas::matmul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matmul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, const double &b, tensor::tensor_Dense< double > &C)
	tensor_Dense tensor multiplication: C = aAB+bC More...
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const double &a, const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, const double &b, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const float &a, const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, const float &b, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	tensor_Dense tensor multiplication: C = AB More...
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensmul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

Detailed Description

Dense matrix multiplication: C = AB.

tensor_Dense tensor multiplication: C = aAB+bC

tensor_Dense tensor multiplication: C = AB

Dense matrix multiplication: C = aAB+bC.

tensor_Dense)

tensor_Dense, Float, tensor_Dense)

Function Documentation

matmul() [1/256]

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

Dense matrix multiplication: C = aAB+bC.

Parameters

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

Note

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

matmul() [2/256]

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

matmul() [3/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [4/256]

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

matmul() [5/256]

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

matmul() [6/256]

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

matmul() [7/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [8/256]

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

matmul() [9/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [10/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [11/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [12/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [13/256]

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

matmul() [14/256]

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

matmul() [15/256]

void monolish::blas::matmul	(	const double &	a,
		const matrix::Dense< double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [16/256]

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

matmul() [17/256]

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

matmul() [18/256]

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

matmul() [19/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [20/256]

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

matmul() [21/256]

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

matmul() [22/256]

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

matmul() [23/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [24/256]

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

matmul() [25/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [26/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [27/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [28/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [29/256]

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

matmul() [30/256]

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

matmul() [31/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< matrix::Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [32/256]

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

matmul() [33/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [34/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [35/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [36/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [37/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [38/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [39/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [40/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [41/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [42/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [43/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [44/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [45/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [46/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [47/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [48/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [49/256]

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

matmul() [50/256]

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

matmul() [51/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const matrix::Dense< double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [52/256]

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

matmul() [53/256]

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

matmul() [54/256]

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

matmul() [55/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [56/256]

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

matmul() [57/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		matrix::Dense< double > &	C
	)

matmul() [58/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< matrix::Dense< double >, double > &	C
	)

matmul() [59/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [60/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [61/256]

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

matmul() [62/256]

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

matmul() [63/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [64/256]

void monolish::blas::matmul	(	const double &	a,
		const view_Dense< vector< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		const double &	b,
		view_Dense< vector< double >, double > &	C
	)

matmul() [65/256]

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

matmul() [66/256]

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

matmul() [67/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [68/256]

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

matmul() [69/256]

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

matmul() [70/256]

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

matmul() [71/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [72/256]

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

matmul() [73/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [74/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [75/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [76/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [77/256]

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

matmul() [78/256]

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

matmul() [79/256]

void monolish::blas::matmul	(	const float &	a,
		const matrix::Dense< float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [80/256]

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

matmul() [81/256]

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

matmul() [82/256]

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

matmul() [83/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [84/256]

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

matmul() [85/256]

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

matmul() [86/256]

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

matmul() [87/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [88/256]

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

matmul() [89/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [90/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [91/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [92/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [93/256]

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

matmul() [94/256]

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

matmul() [95/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< matrix::Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [96/256]

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

matmul() [97/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [98/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [99/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [100/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [101/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [102/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [103/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [104/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [105/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [106/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [107/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [108/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [109/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [110/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [111/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [112/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [113/256]

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

matmul() [114/256]

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

matmul() [115/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const matrix::Dense< float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [116/256]

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

matmul() [117/256]

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

matmul() [118/256]

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

matmul() [119/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [120/256]

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

matmul() [121/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		matrix::Dense< float > &	C
	)

matmul() [122/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< matrix::Dense< float >, float > &	C
	)

matmul() [123/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [124/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [125/256]

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

matmul() [126/256]

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

matmul() [127/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [128/256]

void monolish::blas::matmul	(	const float &	a,
		const view_Dense< vector< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		const float &	b,
		view_Dense< vector< float >, float > &	C
	)

matmul() [129/256]

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

Dense matrix multiplication: C = AB.

Parameters

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

Note

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

matmul() [130/256]

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

matmul() [131/256]

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

matmul() [132/256]

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

matmul() [133/256]

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

matmul() [134/256]

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

matmul() [135/256]

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

matmul() [136/256]

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

matmul() [137/256]

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

matmul() [138/256]

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

matmul() [139/256]

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

matmul() [140/256]

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

matmul() [141/256]

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

matmul() [142/256]

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

matmul() [143/256]

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

matmul() [144/256]

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

matmul() [145/256]

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

matmul() [146/256]

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

matmul() [147/256]

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

matmul() [148/256]

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

matmul() [149/256]

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

matmul() [150/256]

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

matmul() [151/256]

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

matmul() [152/256]

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

matmul() [153/256]

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

matmul() [154/256]

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

matmul() [155/256]

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

matmul() [156/256]

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

matmul() [157/256]

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

matmul() [158/256]

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

matmul() [159/256]

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

matmul() [160/256]

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

matmul() [161/256]

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

matmul() [162/256]

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

matmul() [163/256]

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

matmul() [164/256]

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

matmul() [165/256]

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

matmul() [166/256]

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

matmul() [167/256]

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

matmul() [168/256]

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

matmul() [169/256]

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

matmul() [170/256]

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

matmul() [171/256]

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

matmul() [172/256]

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

matmul() [173/256]

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

matmul() [174/256]

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

matmul() [175/256]

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

matmul() [176/256]

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

matmul() [177/256]

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

matmul() [178/256]

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

matmul() [179/256]

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

matmul() [180/256]

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

matmul() [181/256]

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

matmul() [182/256]

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

matmul() [183/256]

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

matmul() [184/256]

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

matmul() [185/256]

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

matmul() [186/256]

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

matmul() [187/256]

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

matmul() [188/256]

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

matmul() [189/256]

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

matmul() [190/256]

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

matmul() [191/256]

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

matmul() [192/256]

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

matmul() [193/256]

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

matmul() [194/256]

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

matmul() [195/256]

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

matmul() [196/256]

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

matmul() [197/256]

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

matmul() [198/256]

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

matmul() [199/256]

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

matmul() [200/256]

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

matmul() [201/256]

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

matmul() [202/256]

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

matmul() [203/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [204/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_Dense< vector< double >, double > &	C
	)

matmul() [205/256]

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

matmul() [206/256]

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

matmul() [207/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [208/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		view_Dense< vector< double >, double > &	C
	)

matmul() [209/256]

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

matmul() [210/256]

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

matmul() [211/256]

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

matmul() [212/256]

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

matmul() [213/256]

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

matmul() [214/256]

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

matmul() [215/256]

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

matmul() [216/256]

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

matmul() [217/256]

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

matmul() [218/256]

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

matmul() [219/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [220/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_Dense< vector< float >, float > &	C
	)

matmul() [221/256]

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

matmul() [222/256]

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

matmul() [223/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [224/256]

void monolish::blas::matmul	(	const view_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		view_Dense< vector< float >, float > &	C
	)

matmul() [225/256]

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

matmul() [226/256]

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

matmul() [227/256]

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

matmul() [228/256]

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

matmul() [229/256]

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

matmul() [230/256]

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

matmul() [231/256]

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

matmul() [232/256]

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

matmul() [233/256]

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

matmul() [234/256]

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

matmul() [235/256]

void monolish::blas::matmul	(	const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [236/256]

void monolish::blas::matmul	(	const view_Dense< vector< double >, double > &	A,
		const view_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_Dense< vector< double >, double > &	C
	)

matmul() [237/256]

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

matmul() [238/256]

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

matmul() [239/256]

void monolish::blas::matmul	(	const view_Dense< vector< double >, double > &	A,
		const view_Dense< vector< double >, double > &	B,
		view_Dense< tensor::tensor_Dense< double >, double > &	C
	)

matmul() [240/256]

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

matmul() [241/256]

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

matmul() [242/256]

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

matmul() [243/256]

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

matmul() [244/256]

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

matmul() [245/256]

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

matmul() [246/256]

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

matmul() [247/256]

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

matmul() [248/256]

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

matmul() [249/256]

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

matmul() [250/256]

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

matmul() [251/256]

void monolish::blas::matmul	(	const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [252/256]

void monolish::blas::matmul	(	const view_Dense< vector< float >, float > &	A,
		const view_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_Dense< vector< float >, float > &	C
	)

matmul() [253/256]

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

matmul() [254/256]

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

matmul() [255/256]

void monolish::blas::matmul	(	const view_Dense< vector< float >, float > &	A,
		const view_Dense< vector< float >, float > &	B,
		view_Dense< tensor::tensor_Dense< float >, float > &	C
	)

matmul() [256/256]

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

tensmul() [1/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensor_Dense tensor multiplication: C = aAB+bC

Parameters

a	Float
A	tensor_Dense tensor
B	tensor_Dense tensor
b	Float
C	tensor_Dense tensor

Note

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

tensmul() [2/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [3/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [4/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [5/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [6/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [7/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [8/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [9/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [10/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [11/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [12/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [13/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [14/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [15/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [16/256]

void monolish::blas::tensmul	(	const double &	a,
		const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [17/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [18/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [19/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [20/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [21/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [22/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [23/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [24/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [25/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [26/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [27/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [28/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [29/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [30/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [31/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [32/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [33/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [34/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [35/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [36/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [37/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [38/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [39/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [40/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [41/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [42/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [43/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [44/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [45/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [46/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [47/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [48/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [49/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [50/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [51/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [52/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [53/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [54/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [55/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [56/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [57/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [58/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [59/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [60/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [61/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [62/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [63/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [64/256]

void monolish::blas::tensmul	(	const double &	a,
		const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		const double &	b,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [65/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [66/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [67/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [68/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [69/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [70/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [71/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [72/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [73/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [74/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [75/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [76/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [77/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [78/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [79/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [80/256]

void monolish::blas::tensmul	(	const float &	a,
		const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [81/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [82/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [83/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [84/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [85/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [86/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [87/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [88/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [89/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [90/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [91/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [92/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [93/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [94/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [95/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [96/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [97/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [98/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [99/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [100/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [101/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [102/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [103/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [104/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [105/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [106/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [107/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [108/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [109/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [110/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [111/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [112/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [113/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [114/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [115/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [116/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [117/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [118/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [119/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [120/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [121/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [122/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [123/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [124/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [125/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [126/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [127/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [128/256]

void monolish::blas::tensmul	(	const float &	a,
		const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		const float &	b,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [129/256]

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

tensor_Dense tensor multiplication: C = AB

Parameters

A	tensor_Dense tensor
B	tensor_Dense tensor
C	tensor_Dense tensor

Note

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

tensmul() [130/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [131/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [132/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [133/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [134/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [135/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [136/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [137/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [138/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [139/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [140/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [141/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [142/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [143/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [144/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [145/256]

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

tensmul() [146/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [147/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [148/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [149/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [150/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [151/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [152/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [153/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [154/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [155/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [156/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [157/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [158/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [159/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [160/256]

void monolish::blas::tensmul	(	const tensor::tensor_Dense< float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [161/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [162/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [163/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [164/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [165/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [166/256]

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

tensmul() [167/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [168/256]

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

tensmul() [169/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [170/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [171/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [172/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [173/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [174/256]

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

tensmul() [175/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [176/256]

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

tensmul() [177/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [178/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [179/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [180/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [181/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [182/256]

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

tensmul() [183/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [184/256]

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

tensmul() [185/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [186/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [187/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [188/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [189/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [190/256]

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

tensmul() [191/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< matrix::Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [192/256]

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

tensmul() [193/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [194/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [195/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [196/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [197/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [198/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [199/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [200/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [201/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [202/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [203/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [204/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [205/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [206/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [207/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [208/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [209/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [210/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [211/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [212/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [213/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [214/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [215/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [216/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [217/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [218/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [219/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [220/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [221/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [222/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [223/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [224/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [225/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [226/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [227/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [228/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const tensor::tensor_Dense< double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [229/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [230/256]

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

tensmul() [231/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< matrix::Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [232/256]

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

tensmul() [233/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [234/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< matrix::Dense< double >, double > &	C
	)

tensmul() [235/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [236/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [237/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		tensor::tensor_Dense< double > &	C
	)

tensmul() [238/256]

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

tensmul() [239/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< tensor::tensor_Dense< double >, double > &	C
	)

tensmul() [240/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< double >, double > &	A,
		const view_tensor_Dense< vector< double >, double > &	B,
		view_tensor_Dense< vector< double >, double > &	C
	)

tensmul() [241/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [242/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [243/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [244/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const tensor::tensor_Dense< float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [245/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [246/256]

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

tensmul() [247/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< matrix::Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [248/256]

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

tensmul() [249/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [250/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< matrix::Dense< float >, float > &	C
	)

tensmul() [251/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [252/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< tensor::tensor_Dense< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)

tensmul() [253/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		tensor::tensor_Dense< float > &	C
	)

tensmul() [254/256]

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

tensmul() [255/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< tensor::tensor_Dense< float >, float > &	C
	)

tensmul() [256/256]

void monolish::blas::tensmul	(	const view_tensor_Dense< vector< float >, float > &	A,
		const view_tensor_Dense< vector< float >, float > &	B,
		view_tensor_Dense< vector< float >, float > &	C
	)