monolish::blas::matadd (Dense)

Dense matrix addition: C = A + B. More...

Functions
void	monolish::blas::matadd (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Dense matrix addition: C = A + B. More...
void	monolish::blas::matadd (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (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::matadd (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (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::matadd (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matadd (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (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::matadd (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (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::matadd (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::blas::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::matadd (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::matadd (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (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::matadd (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::matadd (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::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::blas::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::matadd (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::matadd (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	Dense tensor addition: C = A + B. More...
void	monolish::blas::tensadd (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensadd (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensadd (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (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::tensadd (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::blas::tensadd (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::tensadd (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::tensadd (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 addition: C = A + B.

tensor_Dense tensor addition: C = A + B

Function Documentation

matadd() [1/128]

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

Dense matrix addition: C = A + B.

Parameters

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

Note

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

matadd() [2/128]

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

matadd() [3/128]

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

matadd() [4/128]

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

matadd() [5/128]

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

matadd() [6/128]

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

matadd() [7/128]

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

matadd() [8/128]

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

matadd() [9/128]

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

matadd() [10/128]

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

matadd() [11/128]

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

matadd() [12/128]

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

matadd() [13/128]

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

matadd() [14/128]

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

matadd() [15/128]

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

matadd() [16/128]

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

matadd() [17/128]

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

matadd() [18/128]

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

matadd() [19/128]

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

matadd() [20/128]

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

matadd() [21/128]

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

matadd() [22/128]

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

matadd() [23/128]

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

matadd() [24/128]

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

matadd() [25/128]

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

matadd() [26/128]

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

matadd() [27/128]

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

matadd() [28/128]

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

matadd() [29/128]

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

matadd() [30/128]

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

matadd() [31/128]

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

matadd() [32/128]

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

matadd() [33/128]

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

matadd() [34/128]

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

matadd() [35/128]

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

matadd() [36/128]

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

matadd() [37/128]

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

matadd() [38/128]

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

matadd() [39/128]

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

matadd() [40/128]

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

matadd() [41/128]

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

matadd() [42/128]

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

matadd() [43/128]

void monolish::blas::matadd	(	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
	)

matadd() [44/128]

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

matadd() [45/128]

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

matadd() [46/128]

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

matadd() [47/128]

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

matadd() [48/128]

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

matadd() [49/128]

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

matadd() [50/128]

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

matadd() [51/128]

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

matadd() [52/128]

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

matadd() [53/128]

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

matadd() [54/128]

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

matadd() [55/128]

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

matadd() [56/128]

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

matadd() [57/128]

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

matadd() [58/128]

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

matadd() [59/128]

void monolish::blas::matadd	(	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
	)

matadd() [60/128]

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

matadd() [61/128]

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

matadd() [62/128]

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

matadd() [63/128]

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

matadd() [64/128]

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

matadd() [65/128]

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

matadd() [66/128]

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

matadd() [67/128]

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

matadd() [68/128]

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

matadd() [69/128]

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

matadd() [70/128]

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

matadd() [71/128]

void monolish::blas::matadd	(	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
	)

matadd() [72/128]

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

matadd() [73/128]

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

matadd() [74/128]

void monolish::blas::matadd	(	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
	)

matadd() [75/128]

void monolish::blas::matadd	(	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
	)

matadd() [76/128]

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

matadd() [77/128]

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

matadd() [78/128]

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

matadd() [79/128]

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

matadd() [80/128]

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

matadd() [81/128]

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

matadd() [82/128]

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

matadd() [83/128]

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

matadd() [84/128]

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

matadd() [85/128]

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

matadd() [86/128]

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

matadd() [87/128]

void monolish::blas::matadd	(	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
	)

matadd() [88/128]

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

matadd() [89/128]

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

matadd() [90/128]

void monolish::blas::matadd	(	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
	)

matadd() [91/128]

void monolish::blas::matadd	(	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
	)

matadd() [92/128]

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

matadd() [93/128]

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

matadd() [94/128]

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

matadd() [95/128]

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

matadd() [96/128]

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

matadd() [97/128]

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

matadd() [98/128]

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

matadd() [99/128]

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

matadd() [100/128]

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

matadd() [101/128]

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

matadd() [102/128]

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

matadd() [103/128]

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

matadd() [104/128]

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

matadd() [105/128]

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

matadd() [106/128]

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

matadd() [107/128]

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

matadd() [108/128]

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

matadd() [109/128]

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

matadd() [110/128]

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

matadd() [111/128]

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

matadd() [112/128]

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

matadd() [113/128]

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

matadd() [114/128]

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

matadd() [115/128]

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

matadd() [116/128]

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

matadd() [117/128]

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

matadd() [118/128]

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

matadd() [119/128]

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

matadd() [120/128]

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

matadd() [121/128]

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

matadd() [122/128]

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

matadd() [123/128]

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

matadd() [124/128]

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

matadd() [125/128]

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

matadd() [126/128]

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

matadd() [127/128]

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

matadd() [128/128]

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

tensadd() [1/128]

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

Dense tensor addition: C = A + B.

Parameters

A	tensor_Dense tensor
B	tensor_Dense tensor
C	tensor_Dense tensor

Note

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

tensadd() [2/128]

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

tensadd() [3/128]

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

tensadd() [4/128]

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

tensadd() [5/128]

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

tensadd() [6/128]

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

tensadd() [7/128]

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

tensadd() [8/128]

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

tensadd() [9/128]

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

tensadd() [10/128]

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

tensadd() [11/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [12/128]

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

tensadd() [13/128]

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

tensadd() [14/128]

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

tensadd() [15/128]

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

tensadd() [16/128]

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

tensadd() [17/128]

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

tensadd() [18/128]

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

tensadd() [19/128]

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

tensadd() [20/128]

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

tensadd() [21/128]

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

tensadd() [22/128]

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

tensadd() [23/128]

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

tensadd() [24/128]

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

tensadd() [25/128]

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

tensadd() [26/128]

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

tensadd() [27/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [28/128]

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

tensadd() [29/128]

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

tensadd() [30/128]

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

tensadd() [31/128]

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

tensadd() [32/128]

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

tensadd() [33/128]

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

tensadd() [34/128]

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

tensadd() [35/128]

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

tensadd() [36/128]

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

tensadd() [37/128]

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

tensadd() [38/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [39/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [40/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [41/128]

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

tensadd() [42/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [43/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [44/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [45/128]

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

tensadd() [46/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [47/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [48/128]

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

tensadd() [49/128]

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

tensadd() [50/128]

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

tensadd() [51/128]

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

tensadd() [52/128]

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

tensadd() [53/128]

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

tensadd() [54/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [55/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [56/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [57/128]

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

tensadd() [58/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [59/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [60/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [61/128]

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

tensadd() [62/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [63/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [64/128]

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

tensadd() [65/128]

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

tensadd() [66/128]

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

tensadd() [67/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [68/128]

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

tensadd() [69/128]

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

tensadd() [70/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [71/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [72/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [73/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [74/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [75/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [76/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [77/128]

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

tensadd() [78/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [79/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [80/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [81/128]

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

tensadd() [82/128]

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

tensadd() [83/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [84/128]

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

tensadd() [85/128]

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

tensadd() [86/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [87/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [88/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [89/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [90/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [91/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [92/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [93/128]

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

tensadd() [94/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [95/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [96/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [97/128]

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

tensadd() [98/128]

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

tensadd() [99/128]

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

tensadd() [100/128]

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

tensadd() [101/128]

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

tensadd() [102/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [103/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [104/128]

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

tensadd() [105/128]

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

tensadd() [106/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [107/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [108/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [109/128]

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

tensadd() [110/128]

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

tensadd() [111/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [112/128]

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

tensadd() [113/128]

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

tensadd() [114/128]

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

tensadd() [115/128]

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

tensadd() [116/128]

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

tensadd() [117/128]

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

tensadd() [118/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [119/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [120/128]

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

tensadd() [121/128]

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

tensadd() [122/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [123/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [124/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [125/128]

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

tensadd() [126/128]

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

tensadd() [127/128]

void monolish::blas::tensadd	(	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
	)

tensadd() [128/128]

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