monolish::blas::matsub (Dense)

Dense matrix subtract: C = A - B. More...

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

tensor_Dense tensor subtract: C = A - B

Function Documentation

matsub() [1/128]

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

Dense matrix subtract: C = A - B.

Parameters

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

Note

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

matsub() [2/128]

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

matsub() [3/128]

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

matsub() [4/128]

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

matsub() [5/128]

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

matsub() [6/128]

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

matsub() [7/128]

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

matsub() [8/128]

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

matsub() [9/128]

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

matsub() [10/128]

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

matsub() [11/128]

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

matsub() [12/128]

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

matsub() [13/128]

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

matsub() [14/128]

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

matsub() [15/128]

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

matsub() [16/128]

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

matsub() [17/128]

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

matsub() [18/128]

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

matsub() [19/128]

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

matsub() [20/128]

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

matsub() [21/128]

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

matsub() [22/128]

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

matsub() [23/128]

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

matsub() [24/128]

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

matsub() [25/128]

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

matsub() [26/128]

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

matsub() [27/128]

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

matsub() [28/128]

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

matsub() [29/128]

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

matsub() [30/128]

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

matsub() [31/128]

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

matsub() [32/128]

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

matsub() [33/128]

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

matsub() [34/128]

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

matsub() [35/128]

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

matsub() [36/128]

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

matsub() [37/128]

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

matsub() [38/128]

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

matsub() [39/128]

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

matsub() [40/128]

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

matsub() [41/128]

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

matsub() [42/128]

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

matsub() [43/128]

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

matsub() [44/128]

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

matsub() [45/128]

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

matsub() [46/128]

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

matsub() [47/128]

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

matsub() [48/128]

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

matsub() [49/128]

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

matsub() [50/128]

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

matsub() [51/128]

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

matsub() [52/128]

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

matsub() [53/128]

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

matsub() [54/128]

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

matsub() [55/128]

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

matsub() [56/128]

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

matsub() [57/128]

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

matsub() [58/128]

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

matsub() [59/128]

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

matsub() [60/128]

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

matsub() [61/128]

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

matsub() [62/128]

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

matsub() [63/128]

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

matsub() [64/128]

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

matsub() [65/128]

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

matsub() [66/128]

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

matsub() [67/128]

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

matsub() [68/128]

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

matsub() [69/128]

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

matsub() [70/128]

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

matsub() [71/128]

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

matsub() [72/128]

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

matsub() [73/128]

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

matsub() [74/128]

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

matsub() [75/128]

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

matsub() [76/128]

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

matsub() [77/128]

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

matsub() [78/128]

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

matsub() [79/128]

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

matsub() [80/128]

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

matsub() [81/128]

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

matsub() [82/128]

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

matsub() [83/128]

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

matsub() [84/128]

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

matsub() [85/128]

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

matsub() [86/128]

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

matsub() [87/128]

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

matsub() [88/128]

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

matsub() [89/128]

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

matsub() [90/128]

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

matsub() [91/128]

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

matsub() [92/128]

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

matsub() [93/128]

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

matsub() [94/128]

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

matsub() [95/128]

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

matsub() [96/128]

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

matsub() [97/128]

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

matsub() [98/128]

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

matsub() [99/128]

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

matsub() [100/128]

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

matsub() [101/128]

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

matsub() [102/128]

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

matsub() [103/128]

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

matsub() [104/128]

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

matsub() [105/128]

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

matsub() [106/128]

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

matsub() [107/128]

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

matsub() [108/128]

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

matsub() [109/128]

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

matsub() [110/128]

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

matsub() [111/128]

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

matsub() [112/128]

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

matsub() [113/128]

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

matsub() [114/128]

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

matsub() [115/128]

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

matsub() [116/128]

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

matsub() [117/128]

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

matsub() [118/128]

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

matsub() [119/128]

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

matsub() [120/128]

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

matsub() [121/128]

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

matsub() [122/128]

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

matsub() [123/128]

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

matsub() [124/128]

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

matsub() [125/128]

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

matsub() [126/128]

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

matsub() [127/128]

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

matsub() [128/128]

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

tenssub() [1/128]

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

Dense tensor subtract: C = A - B.

Parameters

A	tensor_Dense tensor
B	tensor_Dense tensor
C	tensor_Dense tensor

Note

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

tenssub() [2/128]

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

tenssub() [3/128]

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

tenssub() [4/128]

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

tenssub() [5/128]

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

tenssub() [6/128]

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

tenssub() [7/128]

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

tenssub() [8/128]

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

tenssub() [9/128]

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

tenssub() [10/128]

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

tenssub() [11/128]

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

tenssub() [12/128]

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

tenssub() [13/128]

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

tenssub() [14/128]

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

tenssub() [15/128]

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

tenssub() [16/128]

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

tenssub() [17/128]

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

tenssub() [18/128]

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

tenssub() [19/128]

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

tenssub() [20/128]

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

tenssub() [21/128]

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

tenssub() [22/128]

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

tenssub() [23/128]

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

tenssub() [24/128]

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

tenssub() [25/128]

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

tenssub() [26/128]

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

tenssub() [27/128]

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

tenssub() [28/128]

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

tenssub() [29/128]

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

tenssub() [30/128]

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

tenssub() [31/128]

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

tenssub() [32/128]

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

tenssub() [33/128]

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

tenssub() [34/128]

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

tenssub() [35/128]

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

tenssub() [36/128]

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

tenssub() [37/128]

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

tenssub() [38/128]

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

tenssub() [39/128]

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

tenssub() [40/128]

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

tenssub() [41/128]

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

tenssub() [42/128]

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

tenssub() [43/128]

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

tenssub() [44/128]

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

tenssub() [45/128]

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

tenssub() [46/128]

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

tenssub() [47/128]

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

tenssub() [48/128]

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

tenssub() [49/128]

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

tenssub() [50/128]

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

tenssub() [51/128]

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

tenssub() [52/128]

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

tenssub() [53/128]

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

tenssub() [54/128]

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

tenssub() [55/128]

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

tenssub() [56/128]

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

tenssub() [57/128]

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

tenssub() [58/128]

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

tenssub() [59/128]

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

tenssub() [60/128]

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

tenssub() [61/128]

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

tenssub() [62/128]

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

tenssub() [63/128]

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

tenssub() [64/128]

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

tenssub() [65/128]

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

tenssub() [66/128]

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

tenssub() [67/128]

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

tenssub() [68/128]

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

tenssub() [69/128]

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

tenssub() [70/128]

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

tenssub() [71/128]

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

tenssub() [72/128]

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

tenssub() [73/128]

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

tenssub() [74/128]

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

tenssub() [75/128]

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

tenssub() [76/128]

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

tenssub() [77/128]

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

tenssub() [78/128]

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

tenssub() [79/128]

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

tenssub() [80/128]

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

tenssub() [81/128]

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

tenssub() [82/128]

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

tenssub() [83/128]

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

tenssub() [84/128]

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

tenssub() [85/128]

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

tenssub() [86/128]

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

tenssub() [87/128]

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

tenssub() [88/128]

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

tenssub() [89/128]

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

tenssub() [90/128]

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

tenssub() [91/128]

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

tenssub() [92/128]

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

tenssub() [93/128]

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

tenssub() [94/128]

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

tenssub() [95/128]

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

tenssub() [96/128]

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

tenssub() [97/128]

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

tenssub() [98/128]

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

tenssub() [99/128]

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

tenssub() [100/128]

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

tenssub() [101/128]

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

tenssub() [102/128]

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

tenssub() [103/128]

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

tenssub() [104/128]

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

tenssub() [105/128]

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

tenssub() [106/128]

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

tenssub() [107/128]

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

tenssub() [108/128]

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

tenssub() [109/128]

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

tenssub() [110/128]

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

tenssub() [111/128]

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

tenssub() [112/128]

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

tenssub() [113/128]

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

tenssub() [114/128]

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

tenssub() [115/128]

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

tenssub() [116/128]

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

tenssub() [117/128]

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

tenssub() [118/128]

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

tenssub() [119/128]

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

tenssub() [120/128]

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

tenssub() [121/128]

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

tenssub() [122/128]

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

tenssub() [123/128]

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

tenssub() [124/128]

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

tenssub() [125/128]

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

tenssub() [126/128]

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

tenssub() [127/128]

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

tenssub() [128/128]

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