monolish  0.17.3-dev.16
MONOlithic LInear equation Solvers for Highly-parallel architecture
Functions
monolish::vml Namespace Reference

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.