#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 vector< double > &a, const double alpha, vector< double > &y)
	element by element addition of scalar alpha and vector a. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::atanh (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::atanh (const vector< float > &a, vector< float > &y)

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

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

void	monolish::vml::atanh (const vector< float > &a, view1D< vector< float >, float > &y)

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

void	monolish::vml::atanh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

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

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

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

void	monolish::vml::atanh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

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

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

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

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

void	monolish::vml::atanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	monolish::vml::atanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	monolish::vml::atanh (const view1D< vector< double >, double > &a, vector< double > &y)

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

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

void	monolish::vml::atanh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::atanh (const view1D< vector< float >, float > &a, vector< float > &y)

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

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

void	monolish::vml::atanh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

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

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

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

void	monolish::vml::ceil (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::ceil (const vector< float > &a, vector< float > &y)

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

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

void	monolish::vml::ceil (const vector< float > &a, view1D< vector< float >, float > &y)

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

void	monolish::vml::ceil (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

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

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

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

void	monolish::vml::ceil (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

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

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

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

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

void	monolish::vml::ceil (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	monolish::vml::ceil (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	monolish::vml::ceil (const view1D< vector< double >, double > &a, vector< double > &y)

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

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

void	monolish::vml::ceil (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::ceil (const view1D< vector< float >, float > &a, vector< float > &y)

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

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

void	monolish::vml::ceil (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::div (const vector< double > &a, const double alpha, vector< double > &y)
	element by element division of scalar alpha and vector a. More...

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

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

void	monolish::vml::div (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::div (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element division of vector a and vector b. More...

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

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

void	monolish::vml::div (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::div (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::div (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::div (const vector< float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::div (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::div (const vector< float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::div (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::div (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::div (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	monolish::vml::div (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

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

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

void	monolish::vml::div (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::div (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

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

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

void	monolish::vml::div (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::div (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::div (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::div (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::div (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::div (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::div (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::div (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::div (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

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

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

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

void	monolish::vml::exp (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::exp (const vector< float > &a, vector< float > &y)

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

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

void	monolish::vml::exp (const vector< float > &a, view1D< vector< float >, float > &y)

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

void	monolish::vml::exp (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

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

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

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

void	monolish::vml::exp (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

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

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

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

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

void	monolish::vml::exp (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	monolish::vml::exp (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	monolish::vml::exp (const view1D< vector< double >, double > &a, vector< double > &y)

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

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

void	monolish::vml::exp (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::exp (const view1D< vector< float >, float > &a, vector< float > &y)

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

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

void	monolish::vml::exp (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

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

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

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

void	monolish::vml::floor (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::floor (const vector< float > &a, vector< float > &y)

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

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

void	monolish::vml::floor (const vector< float > &a, view1D< vector< float >, float > &y)

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

void	monolish::vml::floor (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

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

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

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

void	monolish::vml::floor (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

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

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

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

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

void	monolish::vml::floor (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

void	monolish::vml::floor (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

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

void	monolish::vml::floor (const view1D< vector< double >, double > &a, vector< double > &y)

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

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

void	monolish::vml::floor (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::floor (const view1D< vector< float >, float > &a, vector< float > &y)

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

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

void	monolish::vml::floor (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::max (const vector< double > &a, const double alpha, vector< double > &y)
	Create a new vector with greatest elements of vector or scalar (y[0:N] = max(a[0:N], alpha)) More...

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

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

void	monolish::vml::max (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::max (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with greatest elements of two matrices (y[0:N] = max(a[0:N], b[0:N])) More...

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

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

void	monolish::vml::max (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::max (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::max (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	monolish::vml::max (const vector< double > &y)
	Finds the greatest element in vector (max(y[0:N])) More...

void	monolish::vml::max (const vector< float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::max (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::max (const vector< float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::max (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::max (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::max (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	monolish::vml::max (const vector< float > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::max (const view1D< matrix::Dense< double >, double > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::max (const view1D< matrix::Dense< float >, float > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::max (const view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::max (const view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::max (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

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

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

void	monolish::vml::max (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::max (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

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

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

void	monolish::vml::max (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::max (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	monolish::vml::max (const view1D< vector< double >, double > &y)

void	monolish::vml::max (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::max (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::max (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::max (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::max (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	monolish::vml::max (const view1D< vector< float >, float > &y)

void	monolish::vml::min (const vector< double > &a, const double alpha, vector< double > &y)
	Create a new vector with smallest elements of vector or scalar (y[0:N] = min(a[0:N], alpha)) More...

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

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

void	monolish::vml::min (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::min (const vector< double > &a, const vector< double > &b, vector< double > &y)
	Create a new vector with smallest elements of two matrices (y[0:N] = min(a[0:N], b[0:N])) More...

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

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

void	monolish::vml::min (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::min (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::min (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	monolish::vml::min (const vector< double > &y)
	Finds the smallest element in vector (min(y[0:N])) More...

void	monolish::vml::min (const vector< float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::min (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::min (const vector< float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::min (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::min (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::min (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	monolish::vml::min (const vector< float > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::min (const view1D< matrix::Dense< double >, double > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::min (const view1D< matrix::Dense< float >, float > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double	monolish::vml::min (const view1D< tensor::tensor_Dense< double >, double > &y)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

float	monolish::vml::min (const view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::min (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

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

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

void	monolish::vml::min (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::min (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

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

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

void	monolish::vml::min (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::min (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

double	monolish::vml::min (const view1D< vector< double >, double > &y)

void	monolish::vml::min (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::min (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::min (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::min (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

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

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

void	monolish::vml::min (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

float	monolish::vml::min (const view1D< vector< float >, float > &y)

void	monolish::vml::mul (const vector< double > &a, const double alpha, vector< double > &y)
	element by element multiplication of scalar alpha and vector a. More...

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

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

void	monolish::vml::mul (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element multiplication of vector a and vector b. More...

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

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

void	monolish::vml::mul (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

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

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

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

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

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

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

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

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

void	monolish::vml::mul (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

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

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

void	monolish::vml::mul (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const vector< float > &a, const float alpha, vector< float > &y)

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

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

void	monolish::vml::mul (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const vector< float > &b, vector< float > &y)

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

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

void	monolish::vml::mul (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

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

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

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

void	monolish::vml::mul (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::mul (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const vector< double > &a, const double alpha, vector< double > &y)
	power to vector elements by double precision scalar value (y[0:N] = pow(a[0:N], alpha)) More...

void	monolish::vml::pow (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const vector< double > &b, vector< double > &y)
	power to vector elements by double precision vector (y[0:N] = pow(a[0:N], b[0]:N])) More...

void	monolish::vml::pow (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const vector< float > &a, const float alpha, vector< float > &y)

void	monolish::vml::pow (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::pow (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::pow (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::reciprocal (const vector< double > &a, vector< double > &y)
	reciprocal to double precision vector elements (y[0:N] = 1 / a[0:N]) More...

void	monolish::vml::reciprocal (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::reciprocal (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::reciprocal (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::reciprocal (const vector< float > &a, vector< float > &y)

void	monolish::vml::reciprocal (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::reciprocal (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::reciprocal (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::reciprocal (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::reciprocal (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::reciprocal (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::reciprocal (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sign (const vector< double > &a, vector< double > &y)
	sign to vector elements (y[0:N] = sign(a[0:N])) More...

void	monolish::vml::sign (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sign (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sign (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sign (const vector< float > &a, vector< float > &y)

void	monolish::vml::sign (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sign (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sign (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sign (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::sign (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sign (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sign (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::sign (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sign (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sin (const vector< double > &a, vector< double > &y)
	sin to vector elements (y[0:N] = sin(a[0:N])) More...

void	monolish::vml::sin (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sin (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sin (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sin (const vector< float > &a, vector< float > &y)

void	monolish::vml::sin (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sin (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sin (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sin (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::sin (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sin (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sin (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::sin (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sin (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sinh (const vector< double > &a, vector< double > &y)
	sinh to vector elements (y[0:N] = sinh(a[0:N])) More...

void	monolish::vml::sinh (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sinh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sinh (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sinh (const vector< float > &a, vector< float > &y)

void	monolish::vml::sinh (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sinh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sinh (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sinh (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::sinh (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sinh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sinh (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::sinh (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sinh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sqrt (const vector< double > &a, vector< double > &y)
	sqrt to vector elements (y[0:N] = sqrt(a[0:N])) More...

void	monolish::vml::sqrt (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sqrt (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sqrt (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sqrt (const vector< float > &a, vector< float > &y)

void	monolish::vml::sqrt (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sqrt (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sqrt (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sqrt (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::sqrt (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sqrt (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::sqrt (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::sqrt (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sqrt (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const vector< double > &a, const double alpha, vector< double > &y)
	element by element subtract of scalar alpha and vector a. More...

void	monolish::vml::sub (const vector< double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element subtract of vector a and vector b. More...

void	monolish::vml::sub (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const vector< float > &a, const float alpha, vector< float > &y)

void	monolish::vml::sub (const vector< float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::sub (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< tensor::tensor_Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const double alpha, vector< double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const double alpha, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const double alpha, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const double alpha, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< tensor::tensor_Dense< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const float alpha, vector< float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const float alpha, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const float alpha, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const float alpha, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< tensor::tensor_Dense< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::sub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)

void	monolish::vml::tan (const vector< double > &a, vector< double > &y)
	tan to vector elements (y[0:N] = tan(a[0:N])) More...

void	monolish::vml::tan (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tan (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tan (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tan (const vector< float > &a, vector< float > &y)

void	monolish::vml::tan (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tan (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tan (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tan (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::tan (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tan (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tan (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::tan (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tan (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tanh (const vector< double > &a, vector< double > &y)
	tanh to vector elements (y[0:N] = tanh(a[0:N])) More...

void	monolish::vml::tanh (const vector< double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tanh (const vector< double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tanh (const vector< double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tanh (const vector< float > &a, vector< float > &y)

void	monolish::vml::tanh (const vector< float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tanh (const vector< float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tanh (const vector< float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< double >, double > &a, vector< double > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< float >, float > &a, vector< float > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< tensor::tensor_Dense< float >, float > &a, view1D< vector< float >, float > &y)

void	monolish::vml::tanh (const view1D< vector< double >, double > &a, vector< double > &y)

void	monolish::vml::tanh (const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< vector< double >, double > &a, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::vml::tanh (const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)

void	monolish::vml::tanh (const view1D< vector< float >, float > &a, vector< float > &y)

void	monolish::vml::tanh (const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< vector< float >, float > &a, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::vml::tanh (const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)

Namespaces

Functions