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

Functions
void	add (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element addition scalar alpha and CRS matrix A. More...

void	add (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element addition CRS matrix A and CRS matrix B. More...

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

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

void	add (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element addition scalar alpha and Dense matrix A. More...

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

void	add (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	add (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element addition Dense matrix A and Dense matrix B. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	add (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	add (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element addition scalar alpha and LinearOperator matrix A. More...

void	add (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	element by element addition LinearOperator matrix A and LinearOperator matrix B. More...

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

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

void	add (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	element by element addition scalar alpha and tensor_Dense tensor A. More...

void	add (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	add (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	add (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	add (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	element by element addition tensor_Dense tensor A and tensor_Dense tensor B. More...

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

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

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

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

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

void	add (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	add (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

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

void	add (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	add (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	add (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

void	add (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	add (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	add (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	add (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	add (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

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

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

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

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

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

void	add (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	add (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

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

void	add (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	add (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	add (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

void	add (const vector< double > &a, const double alpha, vector< double > &y)
	element by element addition of scalar alpha and vector a. More...

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

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

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

void	add (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element addition of vector a and vector b. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	add (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

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

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

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

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

void	add (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	add (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

void	add (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	add (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	add (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

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

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

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

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

void	add (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

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

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

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

void	add (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	add (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

void	add (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	add (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	add (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

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

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

void	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

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

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

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

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

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

void	add (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	add (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	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

void	add (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	add (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	add (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	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

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

void	add (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	add (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

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

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

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

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

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

void	add (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	add (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	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

void	add (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	add (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	add (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	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

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

void	add (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	add (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

void	add (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	add (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

void	add (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	add (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

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

void	add (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

void	add (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	add (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

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

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

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

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

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

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

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

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

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

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

void	add (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	add (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

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

void	add (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	add (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

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

void	add (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

void	add (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	add (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

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

void	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

void	add (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

void	add (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	add (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

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

void	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

void	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

void	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (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	add (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

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

void	add (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	add (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

void	add (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	add (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	add (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	add (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	add (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	add (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	add (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	add (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

void	add (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	add (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	add (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	add (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	add (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	add (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	add (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	add (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	add (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	add (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	add (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	add (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	add (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	alo (const matrix::CRS< double > &A, const double alpha, const double beta, matrix::CRS< double > &C)
	Asymmetric linear operation to CRS matrix elements (C[0:nnz] = alpha max(A[0:nnz], 0) + beta min(A[0:nnz], 0)) More...

void	alo (const matrix::CRS< float > &A, const float alpha, const float beta, matrix::CRS< float > &C)

void	alo (const matrix::Dense< double > &A, const double alpha, const double beta, matrix::Dense< double > &C)
	Asymmetric linear operation to Dense matrix elements (C[0:nnz] = alpha max(A[0:nnz], 0) + beta min(A[0:nnz], 0)) More...

void	alo (const matrix::Dense< double > &A, const double alpha, const double beta, view_Dense< matrix::Dense< double >, double > &C)

void	alo (const matrix::Dense< double > &A, const double alpha, const double beta, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const matrix::Dense< double > &A, const double alpha, const double beta, view_Dense< vector< double >, double > &C)

void	alo (const matrix::Dense< float > &A, const float alpha, const float beta, matrix::Dense< float > &C)

void	alo (const matrix::Dense< float > &A, const float alpha, const float beta, view_Dense< matrix::Dense< float >, float > &C)

void	alo (const matrix::Dense< float > &A, const float alpha, const float beta, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const matrix::Dense< float > &A, const float alpha, const float beta, view_Dense< vector< float >, float > &C)

void	alo (const tensor::tensor_Dense< double > &A, const double alpha, const double beta, tensor::tensor_Dense< double > &C)
	Asymmetric linear operation to tensor_Dense tensor elements (C[0:nnz] = alpha max(A[0:nnz], 0) + beta min(A[0:nnz], 0)) More...

void	alo (const tensor::tensor_Dense< double > &A, const double alpha, const double beta, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	alo (const tensor::tensor_Dense< double > &A, const double alpha, const double beta, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const tensor::tensor_Dense< double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

void	alo (const tensor::tensor_Dense< float > &A, const float alpha, const float beta, tensor::tensor_Dense< float > &C)

void	alo (const tensor::tensor_Dense< float > &A, const float alpha, const float beta, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	alo (const tensor::tensor_Dense< float > &A, const float alpha, const float beta, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const tensor::tensor_Dense< float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

void	alo (const vector< double > &a, const double alpha, const double beta, vector< double > &y)
	Asymmetric linear operation to vector elements (y[0:nnz] = alpha max(a[0:nnz], 0) + beta min(a[0:nnz], 0)) More...

void	alo (const vector< double > &a, const double alpha, const double beta, view1D< matrix::Dense< double >, double > &y)

void	alo (const vector< double > &a, const double alpha, const double beta, view1D< tensor::tensor_Dense< double >, double > &y)

void	alo (const vector< double > &a, const double alpha, const double beta, view1D< vector< double >, double > &y)

void	alo (const vector< float > &a, const float alpha, const float beta, vector< float > &y)

void	alo (const vector< float > &a, const float alpha, const float beta, view1D< matrix::Dense< float >, float > &y)

void	alo (const vector< float > &a, const float alpha, const float beta, view1D< tensor::tensor_Dense< float >, float > &y)

void	alo (const vector< float > &a, const float alpha, const float beta, view1D< vector< float >, float > &y)

void	alo (const view1D< matrix::Dense< double >, double > &a, const double alpha, const double beta, vector< double > &y)

void	alo (const view1D< matrix::Dense< double >, double > &a, const double alpha, const double beta, view1D< matrix::Dense< double >, double > &y)

void	alo (const view1D< matrix::Dense< double >, double > &a, const double alpha, const double beta, view1D< tensor::tensor_Dense< double >, double > &y)

void	alo (const view1D< matrix::Dense< double >, double > &a, const double alpha, const double beta, view1D< vector< double >, double > &y)

void	alo (const view1D< matrix::Dense< float >, float > &a, const float alpha, const float beta, vector< float > &y)

void	alo (const view1D< matrix::Dense< float >, float > &a, const float alpha, const float beta, view1D< matrix::Dense< float >, float > &y)

void	alo (const view1D< matrix::Dense< float >, float > &a, const float alpha, const float beta, view1D< tensor::tensor_Dense< float >, float > &y)

void	alo (const view1D< matrix::Dense< float >, float > &a, const float alpha, const float beta, view1D< vector< float >, float > &y)

void	alo (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, const double beta, vector< double > &y)

void	alo (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, const double beta, view1D< matrix::Dense< double >, double > &y)

void	alo (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, const double beta, view1D< tensor::tensor_Dense< double >, double > &y)

void	alo (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, const double beta, view1D< vector< double >, double > &y)

void	alo (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, const float beta, vector< float > &y)

void	alo (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, const float beta, view1D< matrix::Dense< float >, float > &y)

void	alo (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, const float beta, view1D< tensor::tensor_Dense< float >, float > &y)

void	alo (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, const float beta, view1D< vector< float >, float > &y)

void	alo (const view1D< vector< double >, double > &a, const double alpha, const double beta, vector< double > &y)

void	alo (const view1D< vector< double >, double > &a, const double alpha, const double beta, view1D< matrix::Dense< double >, double > &y)

void	alo (const view1D< vector< double >, double > &a, const double alpha, const double beta, view1D< tensor::tensor_Dense< double >, double > &y)

void	alo (const view1D< vector< double >, double > &a, const double alpha, const double beta, view1D< vector< double >, double > &y)

void	alo (const view1D< vector< float >, float > &a, const float alpha, const float beta, vector< float > &y)

void	alo (const view1D< vector< float >, float > &a, const float alpha, const float beta, view1D< matrix::Dense< float >, float > &y)

void	alo (const view1D< vector< float >, float > &a, const float alpha, const float beta, view1D< tensor::tensor_Dense< float >, float > &y)

void	alo (const view1D< vector< float >, float > &a, const float alpha, const float beta, view1D< vector< float >, float > &y)

void	alo (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, matrix::Dense< double > &C)

void	alo (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_Dense< vector< double >, double > &C)

void	alo (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, matrix::Dense< float > &C)

void	alo (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_Dense< vector< float >, float > &C)

void	alo (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, matrix::Dense< double > &C)

void	alo (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_Dense< vector< double >, double > &C)

void	alo (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, matrix::Dense< float > &C)

void	alo (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_Dense< vector< float >, float > &C)

void	alo (const view_Dense< vector< double >, double > &A, const double alpha, const double beta, matrix::Dense< double > &C)

void	alo (const view_Dense< vector< double >, double > &A, const double alpha, const double beta, view_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_Dense< vector< double >, double > &A, const double alpha, const double beta, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_Dense< vector< double >, double > &A, const double alpha, const double beta, view_Dense< vector< double >, double > &C)

void	alo (const view_Dense< vector< float >, float > &A, const float alpha, const float beta, matrix::Dense< float > &C)

void	alo (const view_Dense< vector< float >, float > &A, const float alpha, const float beta, view_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_Dense< vector< float >, float > &A, const float alpha, const float beta, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_Dense< vector< float >, float > &A, const float alpha, const float beta, view_Dense< vector< float >, float > &C)

void	alo (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, tensor::tensor_Dense< double > &C)

void	alo (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

void	alo (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, tensor::tensor_Dense< float > &C)

void	alo (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, tensor::tensor_Dense< double > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, tensor::tensor_Dense< float > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

void	alo (const view_tensor_Dense< vector< double >, double > &A, const double alpha, const double beta, tensor::tensor_Dense< double > &C)

void	alo (const view_tensor_Dense< vector< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	alo (const view_tensor_Dense< vector< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	alo (const view_tensor_Dense< vector< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

void	alo (const view_tensor_Dense< vector< float >, float > &A, const float alpha, const float beta, tensor::tensor_Dense< float > &C)

void	alo (const view_tensor_Dense< vector< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	alo (const view_tensor_Dense< vector< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	alo (const view_tensor_Dense< vector< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

void	asin (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	asin to CRS matrix elements (C[0:nnz] = asin(A[0:nnz])) More...

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

void	asin (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	asin to Dense matrix elements (C[0:nnz] = asin(A[0:nnz])) More...

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

void	asin (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	asin (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	asin (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	asin to tensor_Dense tensor elements (C[0:nnz] = asin(A[0:nnz])) More...

void	asin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asin (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	asin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asin (const vector< double > &a, vector< double > &y)
	asin to vector elements (y[0:N] = asin(a[0:N])) More...

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

void	asin (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	asin (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	asin (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	asin (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	asin (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	asin (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	asin (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	asin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	asin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	asin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	asin (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	asin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	asin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	asin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	asin (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	asin (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	asin (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	asin (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asin (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	asin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	asin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	asin (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	asin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	asin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asin (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	asin (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	asin (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	asin (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	asin (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	asin (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asin (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	asin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asin (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	asin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asin (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	asin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asin (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	asin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asinh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	asinh to CRS matrix elements (C[0:nnz] = asinh(A[0:nnz])) More...

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

void	asinh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	asinh to Dense matrix elements (C[0:nnz] = asinh(A[0:nnz])) More...

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

void	asinh (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	asinh (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	asinh (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	asinh to tensor_Dense tensor elements (C[0:nnz] = asinh(A[0:nnz])) More...

void	asinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asinh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	asinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asinh (const vector< double > &a, vector< double > &y)
	asinh to vector elements (y[0:N] = asinh(a[0:N])) More...

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

void	asinh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	asinh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	asinh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	asinh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	asinh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	asinh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	asinh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	asinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	asinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	asinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	asinh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	asinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	asinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	asinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	asinh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	asinh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	asinh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	asinh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asinh (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	asinh (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	asinh (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	asinh (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	asinh (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	asinh (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	asinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	asinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	asinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	asinh (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	asinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	asinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	asinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	asinh (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	asinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	asinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	asinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atan (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	atan to CRS matrix elements (C[0:nnz] = atan(A[0:nnz])) More...

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

void	atan (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	atan to Dense matrix elements (C[0:nnz] = atan(A[0:nnz])) More...

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

void	atan (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	atan (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	atan (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	atan to tensor_Dense tensor elements (C[0:nnz] = atan(A[0:nnz])) More...

void	atan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atan (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	atan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atan (const vector< double > &a, vector< double > &y)
	atan to vector elements (y[0:N] = atan(a[0:N])) More...

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

void	atan (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	atan (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	atan (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	atan (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	atan (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	atan (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	atan (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	atan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	atan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	atan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	atan (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	atan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	atan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	atan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	atan (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	atan (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	atan (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	atan (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atan (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	atan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	atan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	atan (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	atan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	atan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atan (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	atan (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	atan (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	atan (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	atan (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	atan (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atan (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	atan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atan (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	atan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atan (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	atan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atan (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	atan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atanh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	atanh to CRS matrix elements (C[0:nnz] = atanh(A[0:nnz])) More...

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

void	atanh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	atanh to Dense matrix elements (C[0:nnz] = atanh(A[0:nnz])) More...

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

void	atanh (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	atanh (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	atanh (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	atanh to tensor_Dense tensor elements (C[0:nnz] = atanh(A[0:nnz])) More...

void	atanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atanh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	atanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atanh (const vector< double > &a, vector< double > &y)
	atanh to vector elements (y[0:N] = atanh(a[0:N])) More...

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

void	atanh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	atanh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	atanh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	atanh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	atanh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	atanh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	atanh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	atanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	atanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	atanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	atanh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	atanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	atanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	atanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	atanh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	atanh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	atanh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	atanh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atanh (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	atanh (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	atanh (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	atanh (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	atanh (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	atanh (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	atanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	atanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	atanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	atanh (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	atanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	atanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	atanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	atanh (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	atanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	atanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	atanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	ceil (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	ceil to CRS matrix elements (C[0:nnz] = ceil(A[0:nnz])) More...

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

void	ceil (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	ceil to Dense matrix elements (C[0:nnz] = ceil(A[0:nnz])) More...

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

void	ceil (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	ceil (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	ceil (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	ceil to tensor_Dense tensor elements (C[0:nnz] = ceil(A[0:nnz])) More...

void	ceil (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	ceil (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	ceil (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	ceil (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	ceil (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	ceil (const vector< double > &a, vector< double > &y)
	ceil to vector elements (y[0:N] = ceil(a[0:N])) More...

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

void	ceil (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	ceil (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	ceil (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	ceil (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	ceil (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	ceil (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	ceil (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	ceil (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	ceil (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	ceil (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	ceil (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	ceil (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	ceil (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	ceil (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	ceil (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	ceil (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	ceil (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	ceil (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	ceil (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	ceil (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	ceil (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	ceil (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	ceil (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	ceil (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	ceil (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	ceil (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	ceil (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	ceil (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	ceil (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	ceil (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	ceil (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	ceil (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	ceil (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	ceil (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	ceil (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	ceil (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	div (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element division scalar alpha and CRS matrix A. More...

void	div (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element division CRS matrix A and CRS matrix B. More...

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

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

void	div (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element division scalar alpha and Dense matrix A. More...

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

void	div (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	div (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element division Dense matrix A and Dense matrix B. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	div (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	div (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element division scalar alpha and LinearOperator matrix A. More...

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

void	div (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	element by element division scalar alpha and tensor_Dense tensor A. More...

void	div (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	div (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	div (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	div (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	element by element division tensor_Dense tensor A and tensor_Dense tensor B. More...

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

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

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

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

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

void	div (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	div (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

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

void	div (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	div (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	div (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

void	div (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	div (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	div (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	div (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	div (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

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

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

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

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

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

void	div (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	div (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

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

void	div (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	div (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	div (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

void	div (const vector< double > &a, const double alpha, vector< double > &y)
	element by element division of scalar alpha and vector a. More...

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

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

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

void	div (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element division of vector a and vector b. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	div (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

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

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

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

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

void	div (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	div (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

void	div (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	div (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	div (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

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

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

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

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

void	div (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

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

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

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

void	div (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	div (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

void	div (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	div (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	div (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

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

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

void	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

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

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

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

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

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

void	div (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	div (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	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

void	div (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	div (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	div (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	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

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

void	div (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	div (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

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

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

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

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

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

void	div (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	div (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	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

void	div (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	div (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	div (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	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

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

void	div (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	div (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

void	div (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	div (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

void	div (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	div (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

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

void	div (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

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

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

void	div (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	div (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

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

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

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

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

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

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

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

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

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

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

void	div (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	div (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

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

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

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

void	div (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	div (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

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

void	div (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

void	div (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	div (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

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

void	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

void	div (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

void	div (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	div (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

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

void	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

void	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

void	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (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	div (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

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

void	div (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	div (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

void	div (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	div (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	div (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	div (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	div (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	div (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	div (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	div (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

void	div (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	div (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	div (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	div (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	div (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	div (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	div (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	div (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	div (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	div (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	div (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	div (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	div (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	exp (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	exp to Dense matrix elements (C[0:nnz] = exp(A[0:nnz])) More...

void	exp (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	exp (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	exp (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	exp (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	exp (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	exp (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	exp to tensor_Dense tensor elements (C[0:nnz] = exp(A[0:nnz])) More...

void	exp (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	exp (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	exp (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	exp (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	exp (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	exp (const vector< double > &a, vector< double > &y)
	exp to vector elements (y[0:N] = exp(a[0:N])) More...

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

void	exp (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	exp (const vector< double > &a, view1D< vector< double >, double > &y)

void	exp (const vector< float > &a, vector< float > &y)

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

void	exp (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	exp (const vector< float > &a, view1D< vector< float >, float > &y)

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

void	exp (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	exp (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	exp (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	exp (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	exp (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	exp (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	exp (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	exp (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	exp (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	exp (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	exp (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	exp (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	exp (const view1D< vector< double >, double > &a, vector< double > &y)

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

void	exp (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	exp (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	exp (const view1D< vector< float >, float > &a, vector< float > &y)

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

void	exp (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	exp (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	exp (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	exp (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	exp (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	exp (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	exp (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	exp (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	exp (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	exp (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	exp (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	exp (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	exp (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	exp (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	exp (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	exp (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	exp (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	exp (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	exp (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	exp (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	exp (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	exp (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	exp (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	exp (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	exp (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	exp (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	floor (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	floor to CRS matrix elements (C[0:nnz] = floor(A[0:nnz])) More...

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

void	floor (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	floor to Dense matrix elements (C[0:nnz] = floor(A[0:nnz])) More...

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

void	floor (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

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

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

void	floor (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	floor (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	floor to tensor_Dense tensor elements (C[0:nnz] = floor(A[0:nnz])) More...

void	floor (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	floor (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	floor (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	floor (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	floor (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	floor (const vector< double > &a, vector< double > &y)
	floor to vector elements (y[0:N] = floor(a[0:N])) More...

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

void	floor (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	floor (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

void	floor (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	floor (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

void	floor (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	floor (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	floor (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	floor (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	floor (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	floor (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	floor (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	floor (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	floor (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	floor (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

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

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

void	floor (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	floor (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

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

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

void	floor (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

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

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

void	floor (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	floor (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	floor (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	floor (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	floor (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	floor (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	floor (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	floor (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	floor (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	floor (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	floor (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	floor (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	floor (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	floor (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	floor (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	floor (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	floor (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	floor (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	floor (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	floor (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	floor (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	floor (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	floor (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	floor (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	floor (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	max (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	Create a new CRS matrix with greatest elements of CRS matrix or scalar (C[0:nnz] = max(A[0:nnz], alpha)) More...

void	max (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	Create a new CRS matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...

double	max (const matrix::CRS< double > &C)
	Finds the greatest element in CRS matrix (max(C[0:nnz])) More...

void	max (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)

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

float	max (const matrix::CRS< float > &C)

void	max (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	Create a new Dense matrix with greatest elements of Dense matrix or scalar (C[0:nnz] = max(A[0:nnz], alpha)) More...

void	max (const matrix::Dense< double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	max (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const matrix::Dense< double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...

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

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

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

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

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

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

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

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

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

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

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

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

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

void	max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	max (const matrix::Dense< double > &C)
	Finds the greatest element in Dense matrix (max(C[0:nnz])) More...

void	max (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)

void	max (const matrix::Dense< float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	max (const matrix::Dense< float > &C)

void	max (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	Create a new tensor_Dense tensor with greatest elements of tensor_Dense tensor or scalar (C[0:nnz] = max(A[0:nnz], alpha)) More...

void	max (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	Create a new tensor_Dense tensor with greatest elements of two tensors (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...

void	max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (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	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	max (const tensor::tensor_Dense< double > &C)
	Finds the greatest element in tensor_Dense tensor (max(C[0:nnz])) More...

void	max (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	max (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (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	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	max (const tensor::tensor_Dense< float > &C)

void	max (const vector< double > &a, const double alpha, vector< double > &y)
	Create a new vector with greatest elements of vector or scalar (y[0:N] = max(a[0:N], alpha)) More...

void	max (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	max (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	max (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with greatest elements of two matrices (y[0:N] = max(a[0:N], b[0:N])) More...

void	max (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	max (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	max (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	max (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	max (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	max (const vector< double > &y)
	Finds the greatest element in vector (max(y[0:N])) More...

void	max (const vector< float > &a, const float alpha, vector< float > &y)

void	max (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	max (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	max (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	max (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	max (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	max (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	max (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	max (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	max (const vector< float > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	max (const view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	max (const view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	max (const view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	max (const view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	max (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	max (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	max (const view1D< vector< double >, double > &y)

void	max (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	max (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	max (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	max (const view1D< vector< float >, float > &y)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (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	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (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	max (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	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	max (const view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (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	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (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	max (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	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	max (const view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (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	max (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	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (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	max (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	max (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	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (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	max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	max (const view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (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	max (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	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (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	max (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	max (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	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (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	max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	max (const view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< vector< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	max (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (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	max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	max (const view_Dense< vector< double >, double > &C)

void	max (const view_Dense< vector< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	max (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (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	max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	max (const view_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (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	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	max (const view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (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	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	max (const view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (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)

double	max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (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	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (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)

float	max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (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	max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (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	max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	max (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	max (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	max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	max (const view_tensor_Dense< vector< double >, double > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (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	max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (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	max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	max (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	max (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	max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	max (const view_tensor_Dense< vector< float >, float > &C)

void	min (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	Create a new CRS matrix with smallest elements of CRS matrix or scalar (C[0:nnz] = min(A[0:nnz], alpha)) More...

void	min (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	Create a new CRS matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz])) More...

double	min (const matrix::CRS< double > &C)
	Finds the smallest element in CRS matrix (min(C[0:nnz])) More...

void	min (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)

void	min (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)

float	min (const matrix::CRS< float > &C)

void	min (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	Create a new Dense matrix with smallest elements of Dense matrix or scalar (C[0:nnz] = min(A[0:nnz], alpha)) More...

void	min (const matrix::Dense< double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	min (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Create a new Dense matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz], B[0:nnz])) More...

void	min (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	min (const matrix::Dense< double > &C)
	Finds the smallest element in Dense matrix (min(C[0:nnz])) More...

void	min (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)

void	min (const matrix::Dense< float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	min (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	min (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	min (const matrix::Dense< float > &C)

void	min (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	Create a new tensor_Dense tensor with smallest elements of tensor_Dense tensor or scalar (C[0:nnz] = min(A[0:nnz], alpha)) More...

void	min (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	Create a new tensor_Dense tensor with smallest elements of two tensors (C[0:nnz] = min(A[0:nnz], B[0:nnz])) More...

void	min (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (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	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	min (const tensor::tensor_Dense< double > &C)
	Finds the smallest element in tensor_Dense tensor (min(C[0:nnz])) More...

void	min (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	min (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	min (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (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	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	min (const tensor::tensor_Dense< float > &C)

void	min (const vector< double > &a, const double alpha, vector< double > &y)
	Create a new vector with smallest elements of vector or scalar (y[0:N] = min(a[0:N], alpha)) More...

void	min (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	min (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	min (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with smallest elements of two matrices (y[0:N] = min(a[0:N], b[0:N])) More...

void	min (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	min (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	min (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	min (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	min (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	min (const vector< double > &y)
	Finds the smallest element in vector (min(y[0:N])) More...

void	min (const vector< float > &a, const float alpha, vector< float > &y)

void	min (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	min (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	min (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	min (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	min (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	min (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	min (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	min (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	min (const vector< float > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	min (const view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	min (const view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	min (const view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	min (const view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	min (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	min (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	min (const view1D< vector< double >, double > &y)

void	min (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	min (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	min (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	min (const view1D< vector< float >, float > &y)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (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	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (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	min (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	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	min (const view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (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	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (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	min (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	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	min (const view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (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	min (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	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (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	min (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	min (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	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (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	min (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	min (const view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (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	min (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	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (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	min (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	min (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	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (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	min (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	min (const view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< vector< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	min (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (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	min (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

double	min (const view_Dense< vector< double >, double > &C)

void	min (const view_Dense< vector< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	min (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (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	min (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

float	min (const view_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (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	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	min (const view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (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	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	min (const view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (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)

double	min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (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	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (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)

float	min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (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	min (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (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	min (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	min (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	min (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	min (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

double	min (const view_tensor_Dense< vector< double >, double > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	min (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (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	min (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (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	min (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	min (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	min (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	min (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

float	min (const view_tensor_Dense< vector< float >, float > &C)

void	mul (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element multiplication scalar alpha and CRS matrix A. More...

void	mul (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element multiplication CRS matrix A and CRS matrix B. More...

void	mul (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)

void	mul (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)

void	mul (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element multiplication scalar alpha and Dense matrix A. More...

void	mul (const matrix::Dense< double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element multiplication Dense matrix A and Dense matrix B. More...

void	mul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)

void	mul (const matrix::Dense< float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	mul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element multiplication scalar alpha and LinearOperator matrix A. More...

void	mul (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)

void	mul (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	element by element multiplication scalar alpha and tensor_Dense tensor A. More...

void	mul (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	element by element multiplication tensor_Dense tensor A and tensor_Dense tensor B. More...

void	mul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (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	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (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	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const vector< double > &a, const double alpha, vector< double > &y)
	element by element multiplication of scalar alpha and vector a. More...

void	mul (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	mul (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	mul (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element multiplication of vector a and vector b. More...

void	mul (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	mul (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const vector< float > &a, const float alpha, vector< float > &y)

void	mul (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	mul (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	mul (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	mul (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	mul (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	mul (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	mul (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (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	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (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	mul (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	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (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	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (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	mul (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	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (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	mul (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	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (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	mul (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (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	mul (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	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (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	mul (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< vector< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (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	mul (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	mul (const view_Dense< vector< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (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	mul (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (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	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (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	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	mul (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	mul (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	mul (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	mul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (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	mul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	mul (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	mul (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	mul (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	power to CRS matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha)) More...

void	pow (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	power to CRS matrix elements (C[0:N] = pow(A[0:N], B[0:N])) More...

void	pow (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)

void	pow (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)

void	pow (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	power to Dense matrix elements by scalar value (C[0:N] = pow(A[0:N], alpha)) More...

void	pow (const matrix::Dense< double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	power to Dense matrix elements (C[0:N] = pow(A[0:N], B[0:N])) More...

void	pow (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)

void	pow (const matrix::Dense< float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	pow (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	power to tensor_Dense tensor elements by scalar value (C[0:N] = pow(A[0:N], alpha)) More...

void	pow (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	power to tensor_Dense tensor elements (C[0:N] = pow(A[0:N], B[0:N])) More...

void	pow (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (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	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (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	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const vector< double > &a, const double alpha, vector< double > &y)
	power to vector elements by double precision scalar value (y[0:N] = pow(a[0:N], alpha)) More...

void	pow (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	pow (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	pow (const vector< double > &a, const vector< double > &b, vector< double > &y)
	power to vector elements by double precision vector (y[0:N] = pow(a[0:N], b[0]:N])) More...

void	pow (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const vector< float > &a, const float alpha, vector< float > &y)

void	pow (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	pow (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	pow (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	pow (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	pow (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	pow (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	pow (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (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	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (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	pow (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	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (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	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (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	pow (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	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (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	pow (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	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (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	pow (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (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	pow (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	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (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	pow (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< vector< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (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	pow (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	pow (const view_Dense< vector< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (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	pow (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (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	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (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	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	pow (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	pow (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	pow (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	pow (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (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	pow (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	pow (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	pow (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	pow (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	reciprocal (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	reciprocal to CRS matrix elements (C[0:nnz] = 1 / A[0:nnz]) More...

void	reciprocal (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	reciprocal (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	Compute reciprocal to Dense matrix elements (C[0:nnz] = 1 / A[0:nnz]) More...

void	reciprocal (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	reciprocal (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	reciprocal (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	reciprocal (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	Compute reciprocal to tensor_Dense tensor elements (C[0:nnz] = 1 / A[0:nnz]) More...

void	reciprocal (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	reciprocal (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	reciprocal (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	reciprocal (const vector< double > &a, vector< double > &y)
	reciprocal to double precision vector elements (y[0:N] = 1 / a[0:N]) More...

void	reciprocal (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	reciprocal (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	reciprocal (const vector< double > &a, view1D< vector< double >, double > &y)

void	reciprocal (const vector< float > &a, vector< float > &y)

void	reciprocal (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	reciprocal (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	reciprocal (const vector< float > &a, view1D< vector< float >, float > &y)

void	reciprocal (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	reciprocal (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	reciprocal (const view1D< vector< double >, double > &a, vector< double > &y)

void	reciprocal (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	reciprocal (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	reciprocal (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	reciprocal (const view1D< vector< float >, float > &a, vector< float > &y)

void	reciprocal (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	reciprocal (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	reciprocal (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	reciprocal (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	reciprocal (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	reciprocal (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	reciprocal (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	reciprocal (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	reciprocal (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	reciprocal (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	reciprocal (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	reciprocal (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	reciprocal (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	reciprocal (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	reciprocal (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	reciprocal (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	reciprocal (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sign (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sign to CRS matrix elements (C[0:nnz] = sign(A[0:nnz])) More...

void	sign (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	sign (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sign to Dense matrix elements (C[0:nnz] = sign(A[0:nnz])) More...

void	sign (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sign (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	sign (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	sign (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sign (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	sign (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	sign to tensor_Dense tensor elements (C[0:nnz] = sign(A[0:nnz])) More...

void	sign (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sign (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sign (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	sign (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sign (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sign (const vector< double > &a, vector< double > &y)
	sign to vector elements (y[0:N] = sign(a[0:N])) More...

void	sign (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	sign (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sign (const vector< double > &a, view1D< vector< double >, double > &y)

void	sign (const vector< float > &a, vector< float > &y)

void	sign (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	sign (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sign (const vector< float > &a, view1D< vector< float >, float > &y)

void	sign (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	sign (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sign (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sign (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sign (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	sign (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sign (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sign (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sign (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sign (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sign (const view1D< vector< double >, double > &a, vector< double > &y)

void	sign (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sign (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sign (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	sign (const view1D< vector< float >, float > &a, vector< float > &y)

void	sign (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sign (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sign (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	sign (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	sign (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sign (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	sign (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sign (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	sign (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sign (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	sign (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sign (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	sign (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sign (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	sign (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sign (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sign (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sign (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sign (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sign (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sign (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sign (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sign (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sign (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sign (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sign (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sign (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sin (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sin to CRS matrix elements (C[0:nnz] = sin(A[0:nnz])) More...

void	sin (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	sin (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sin to Dense matrix elements (C[0:nnz] = sin(A[0:nnz])) More...

void	sin (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sin (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	sin (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	sin (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sin (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	sin (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	sin to tensor_Dense tensor elements (C[0:nnz] = sin(A[0:nnz])) More...

void	sin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sin (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	sin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sin (const vector< double > &a, vector< double > &y)
	sin to vector elements (y[0:N] = sin(a[0:N])) More...

void	sin (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	sin (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sin (const vector< double > &a, view1D< vector< double >, double > &y)

void	sin (const vector< float > &a, vector< float > &y)

void	sin (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	sin (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sin (const vector< float > &a, view1D< vector< float >, float > &y)

void	sin (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	sin (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sin (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sin (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sin (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	sin (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sin (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sin (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sin (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sin (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sin (const view1D< vector< double >, double > &a, vector< double > &y)

void	sin (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sin (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sin (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	sin (const view1D< vector< float >, float > &a, vector< float > &y)

void	sin (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sin (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sin (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	sin (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	sin (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sin (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	sin (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sin (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	sin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sin (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	sin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sin (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	sin (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sin (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	sin (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sin (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sin (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sin (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sin (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sinh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sinh to CRS matrix elements (C[0:nnz] = sinh(A[0:nnz])) More...

void	sinh (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	sinh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sinh to Dense matrix elements (C[0:nnz] = sinh(A[0:nnz])) More...

void	sinh (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sinh (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	sinh (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	sinh (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sinh (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	sinh (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	sinh to tensor_Dense tensor elements (C[0:nnz] = sinh(A[0:nnz])) More...

void	sinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sinh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	sinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sinh (const vector< double > &a, vector< double > &y)
	sinh to vector elements (y[0:N] = sinh(a[0:N])) More...

void	sinh (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	sinh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sinh (const vector< double > &a, view1D< vector< double >, double > &y)

void	sinh (const vector< float > &a, vector< float > &y)

void	sinh (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	sinh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sinh (const vector< float > &a, view1D< vector< float >, float > &y)

void	sinh (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	sinh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sinh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sinh (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sinh (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	sinh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sinh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sinh (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sinh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sinh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sinh (const view1D< vector< double >, double > &a, vector< double > &y)

void	sinh (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sinh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sinh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	sinh (const view1D< vector< float >, float > &a, vector< float > &y)

void	sinh (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sinh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sinh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	sinh (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	sinh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sinh (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	sinh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sinh (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	sinh (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sinh (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	sinh (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sinh (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sinh (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sqrt (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	sqrt to CRS matrix elements (C[0:nnz] = sqrt(A[0:nnz])) More...

void	sqrt (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	sqrt (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	sqrt to Dense matrix elements (C[0:nnz] = sqrt(A[0:nnz])) More...

void	sqrt (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	sqrt (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	sqrt (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	sqrt (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	sqrt to tensor_Dense tensor elements (C[0:nnz] = sqrt(A[0:nnz])) More...

void	sqrt (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sqrt (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	sqrt (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sqrt (const vector< double > &a, vector< double > &y)
	sqrt to vector elements (y[0:N] = sqrt(a[0:N])) More...

void	sqrt (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	sqrt (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sqrt (const vector< double > &a, view1D< vector< double >, double > &y)

void	sqrt (const vector< float > &a, vector< float > &y)

void	sqrt (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	sqrt (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sqrt (const vector< float > &a, view1D< vector< float >, float > &y)

void	sqrt (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sqrt (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	sqrt (const view1D< vector< double >, double > &a, vector< double > &y)

void	sqrt (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	sqrt (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	sqrt (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	sqrt (const view1D< vector< float >, float > &a, vector< float > &y)

void	sqrt (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	sqrt (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	sqrt (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	sqrt (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	sqrt (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sqrt (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	sqrt (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sqrt (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	sqrt (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	sqrt (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	sqrt (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sqrt (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	sqrt (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sqrt (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	sqrt (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	sqrt (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sqrt (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	sub (const matrix::CRS< double > &A, const double alpha, matrix::CRS< double > &C)
	element by element subtract scalar alpha and CRS matrix A. More...

void	sub (const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
	element by element subtract CRS matrix A and CRS matrix B. More...

void	sub (const matrix::CRS< float > &A, const float alpha, matrix::CRS< float > &C)

void	sub (const matrix::CRS< float > &A, const matrix::CRS< float > &B, matrix::CRS< float > &C)

void	sub (const matrix::Dense< double > &A, const double alpha, matrix::Dense< double > &C)
	element by element subtract scalar alpha and Dense matrix A. More...

void	sub (const matrix::Dense< double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	element by element subtract Dense matrix A and Dense matrix B. More...

void	sub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const matrix::Dense< float > &A, const float alpha, matrix::Dense< float > &C)

void	sub (const matrix::Dense< float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	sub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const matrix::LinearOperator< double > &A, const double &alpha, matrix::LinearOperator< double > &C)
	element by element subtract scalar alpha and LinearOperator matrix A. More...

void	sub (const matrix::LinearOperator< double > &A, const matrix::LinearOperator< double > &B, matrix::LinearOperator< double > &C)
	element by element subtract LinearOperator matrix A and LinearOperator matrix B. More...

void	sub (const matrix::LinearOperator< float > &A, const float &alpha, matrix::LinearOperator< float > &C)

void	sub (const matrix::LinearOperator< float > &A, const matrix::LinearOperator< float > &B, matrix::LinearOperator< float > &C)

void	sub (const tensor::tensor_Dense< double > &A, const double alpha, tensor::tensor_Dense< double > &C)
	element by element subtract scalar alpha and tensor_Dense tensor A. More...

void	sub (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	element by element subtract tensor_Dense tensor A and tensor_Dense tensor B. More...

void	sub (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (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	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (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	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const vector< double > &a, const double alpha, vector< double > &y)
	element by element subtract of scalar alpha and vector a. More...

void	sub (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	sub (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	sub (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element subtract of vector a and vector b. More...

void	sub (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const vector< float > &a, const float alpha, vector< float > &y)

void	sub (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	sub (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	sub (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	sub (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	sub (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	sub (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	sub (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (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	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (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	sub (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	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (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	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (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	sub (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	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (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	sub (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	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (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	sub (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (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	sub (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	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (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	sub (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< vector< double >, double > &A, const double alpha, matrix::Dense< double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const double alpha, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (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	sub (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)

void	sub (const view_Dense< vector< float >, float > &A, const float alpha, matrix::Dense< float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const float alpha, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (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	sub (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (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	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (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	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< vector< double >, double > &A, const double alpha, tensor::tensor_Dense< double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)

void	sub (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	sub (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	sub (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const float alpha, tensor::tensor_Dense< float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)

void	sub (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (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	sub (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)

void	sub (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	sub (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	sub (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

void	tan (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	tan to CRS matrix elements (C[0:nnz] = tan(A[0:nnz])) More...

void	tan (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	tan (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	tan to Dense matrix elements (C[0:nnz] = tan(A[0:nnz])) More...

void	tan (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tan (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	tan (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	tan (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tan (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	tan (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	tan to tensor_Dense tensor elements (C[0:nnz] = tan(A[0:nnz])) More...

void	tan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tan (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	tan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tan (const vector< double > &a, vector< double > &y)
	tan to vector elements (y[0:N] = tan(a[0:N])) More...

void	tan (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	tan (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tan (const vector< double > &a, view1D< vector< double >, double > &y)

void	tan (const vector< float > &a, vector< float > &y)

void	tan (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	tan (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tan (const vector< float > &a, view1D< vector< float >, float > &y)

void	tan (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	tan (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tan (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tan (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	tan (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	tan (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tan (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tan (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	tan (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	tan (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	tan (const view1D< vector< double >, double > &a, vector< double > &y)

void	tan (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tan (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tan (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	tan (const view1D< vector< float >, float > &a, vector< float > &y)

void	tan (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tan (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tan (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	tan (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	tan (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tan (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	tan (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tan (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	tan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tan (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	tan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tan (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	tan (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tan (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	tan (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tan (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tan (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tan (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tan (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tanh (const matrix::CRS< double > &A, matrix::CRS< double > &C)
	tanh to CRS matrix elements (C[0:nnz] = tanh(A[0:nnz])) More...

void	tanh (const matrix::CRS< float > &A, matrix::CRS< float > &C)

void	tanh (const matrix::Dense< double > &A, matrix::Dense< double > &C)
	tanh to Dense matrix elements (C[0:nnz] = tanh(A[0:nnz])) More...

void	tanh (const matrix::Dense< double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tanh (const matrix::Dense< double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const matrix::Dense< double > &A, view_Dense< vector< double >, double > &C)

void	tanh (const matrix::Dense< float > &A, matrix::Dense< float > &C)

void	tanh (const matrix::Dense< float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tanh (const matrix::Dense< float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const matrix::Dense< float > &A, view_Dense< vector< float >, float > &C)

void	tanh (const tensor::tensor_Dense< double > &A, tensor::tensor_Dense< double > &C)
	tanh to tensor_Dense tensor elements (C[0:nnz] = tanh(A[0:nnz])) More...

void	tanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tanh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

void	tanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tanh (const vector< double > &a, vector< double > &y)
	tanh to vector elements (y[0:N] = tanh(a[0:N])) More...

void	tanh (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	tanh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tanh (const vector< double > &a, view1D< vector< double >, double > &y)

void	tanh (const vector< float > &a, vector< float > &y)

void	tanh (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	tanh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tanh (const vector< float > &a, view1D< vector< float >, float > &y)

void	tanh (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	tanh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tanh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tanh (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	tanh (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	tanh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tanh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tanh (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	tanh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	tanh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	tanh (const view1D< vector< double >, double > &a, vector< double > &y)

void	tanh (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	tanh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	tanh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	tanh (const view1D< vector< float >, float > &a, vector< float > &y)

void	tanh (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	tanh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	tanh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	tanh (const view_Dense< matrix::Dense< double >, double > &A, matrix::Dense< double > &C)

void	tanh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_Dense< matrix::Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tanh (const view_Dense< matrix::Dense< float >, float > &A, matrix::Dense< float > &C)

void	tanh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_Dense< matrix::Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, matrix::Dense< double > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, matrix::Dense< float > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_Dense< tensor::tensor_Dense< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tanh (const view_Dense< vector< double >, double > &A, matrix::Dense< double > &C)

void	tanh (const view_Dense< vector< double >, double > &A, view_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_Dense< vector< double >, double > &A, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_Dense< vector< double >, double > &A, view_Dense< vector< double >, double > &C)

void	tanh (const view_Dense< vector< float >, float > &A, matrix::Dense< float > &C)

void	tanh (const view_Dense< vector< float >, float > &A, view_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_Dense< vector< float >, float > &A, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_Dense< vector< float >, float > &A, view_Dense< vector< float >, float > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	tanh (const view_tensor_Dense< vector< double >, double > &A, tensor::tensor_Dense< double > &C)

void	tanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

void	tanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

void	tanh (const view_tensor_Dense< vector< float >, float > &A, tensor::tensor_Dense< float > &C)

void	tanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

void	tanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

Detailed Description

Vector and Matrix element-wise math library.

Functions

Detailed Description