#include "../common/monolish_common.hpp"

Go to the source code of this file.

Namespaces
	monolish
	monolish namespaces

	monolish::vml
	Vector and Matrix element-wise math library.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::alo (const tensor::tensor_Dense< double > &A, const double alpha, const double beta, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::alo (const view_tensor_Dense< matrix::Dense< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::alo (const view_tensor_Dense< matrix::Dense< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

void	monolish::vml::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	monolish::vml::alo (const view_tensor_Dense< vector< double >, double > &A, const double alpha, const double beta, view_tensor_Dense< vector< double >, double > &C)

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

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

void	monolish::vml::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	monolish::vml::alo (const view_tensor_Dense< vector< float >, float > &A, const float alpha, const float beta, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::asin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::asinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::atan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::atanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::atanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::atanh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::atanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::atanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

void	monolish::vml::atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::atanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::atanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::atanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::atanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::ceil (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::ceil (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::ceil (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::ceil (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::ceil (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::ceil (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::ceil (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::ceil (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::ceil (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::ceil (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::div (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::div (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::div (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

void	monolish::vml::div (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::exp (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::exp (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::exp (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::exp (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::exp (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::exp (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::exp (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::exp (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::exp (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::exp (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::floor (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::floor (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::floor (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::floor (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::floor (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::floor (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::floor (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::floor (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::floor (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::floor (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::max (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::max (const tensor::tensor_Dense< double > &C)
	Finds the greatest element in tensor_Dense tensor (max(C[0:nnz])) More...

void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::max (const tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::min (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::min (const tensor::tensor_Dense< double > &C)
	Finds the smallest element in tensor_Dense tensor (min(C[0:nnz])) More...

void	monolish::vml::min (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::min (const tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

void	monolish::vml::min (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::min (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::min (const view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::mul (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::mul (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::mul (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

void	monolish::vml::mul (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::pow (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::pow (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::pow (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

void	monolish::vml::pow (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::reciprocal (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::reciprocal (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::reciprocal (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::reciprocal (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::reciprocal (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::reciprocal (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::reciprocal (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::reciprocal (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::reciprocal (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::reciprocal (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::sign (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::sign (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sign (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sign (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::sign (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::sign (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::sign (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sign (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::sign (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::sign (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::sin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::sin (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sin (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sin (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::sin (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::sin (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::sin (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sin (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::sin (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::sin (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::sinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::sinh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sinh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sinh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::sinh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::sinh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::sinh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sinh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::sinh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::sinh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::sqrt (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::sqrt (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sqrt (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sqrt (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::sqrt (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::sqrt (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::sqrt (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::sqrt (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::sqrt (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::sqrt (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::sub (const tensor::tensor_Dense< double > &A, const double alpha, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::sub (const tensor::tensor_Dense< float > &A, const float alpha, tensor::tensor_Dense< float > &C)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::sub (const view_tensor_Dense< vector< double >, double > &A, const double alpha, view_tensor_Dense< vector< double >, double > &C)

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

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

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

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

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

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

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

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

void	monolish::vml::sub (const view_tensor_Dense< vector< float >, float > &A, const float alpha, view_tensor_Dense< vector< float >, float > &C)

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

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

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

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

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

void	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::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	monolish::vml::tan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::tan (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::tan (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::tan (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::tan (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::tan (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::tan (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::tan (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::tan (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::tan (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

void	monolish::vml::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	monolish::vml::tanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

void	monolish::vml::tanh (const tensor::tensor_Dense< double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::tanh (const tensor::tensor_Dense< float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::tanh (const tensor::tensor_Dense< float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

void	monolish::vml::tanh (const view_tensor_Dense< matrix::Dense< double >, double > &A, view_tensor_Dense< matrix::Dense< double >, double > &C)

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

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

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

void	monolish::vml::tanh (const view_tensor_Dense< matrix::Dense< float >, float > &A, view_tensor_Dense< matrix::Dense< float >, float > &C)

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

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

void	monolish::vml::tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, tensor::tensor_Dense< double > &C)

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

void	monolish::vml::tanh (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)

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

void	monolish::vml::tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, tensor::tensor_Dense< float > &C)

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

void	monolish::vml::tanh (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)

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

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

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

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

void	monolish::vml::tanh (const view_tensor_Dense< vector< double >, double > &A, view_tensor_Dense< vector< double >, double > &C)

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

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

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

void	monolish::vml::tanh (const view_tensor_Dense< vector< float >, float > &A, view_tensor_Dense< vector< float >, float > &C)

Namespaces

Functions