monolish::vml::max

Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...

Functions
void	monolish::vml::max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
	Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...
void	monolish::vml::max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const matrix::Dense< float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
	Create a new tensor_Dense tensor with greatest elements of two tensors (C[0:nnz] = max(A[0:nnz], B[0:nnz])) More...
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const tensor::tensor_Dense< float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< matrix::Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const matrix::Dense< double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< matrix::Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< tensor::tensor_Dense< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, matrix::Dense< double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< double >, double > &A, const view_Dense< vector< double >, double > &B, view_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const matrix::Dense< float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< matrix::Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< tensor::tensor_Dense< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, matrix::Dense< float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_Dense< vector< float >, float > &A, const view_Dense< vector< float >, float > &B, view_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< matrix::Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< tensor::tensor_Dense< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const tensor::tensor_Dense< double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< matrix::Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< tensor::tensor_Dense< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, tensor::tensor_Dense< double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< matrix::Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< tensor::tensor_Dense< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< double >, double > &A, const view_tensor_Dense< vector< double >, double > &B, view_tensor_Dense< vector< double >, double > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const tensor::tensor_Dense< float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< matrix::Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< tensor::tensor_Dense< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, tensor::tensor_Dense< float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< matrix::Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< tensor::tensor_Dense< float >, float > &C)
void	monolish::vml::max (const view_tensor_Dense< vector< float >, float > &A, const view_tensor_Dense< vector< float >, float > &B, view_tensor_Dense< vector< float >, float > &C)

Detailed Description

Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Create a new tensor_Dense tensor with greatest elements of two tensors (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Function Documentation

max() [1/256]

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

Create a new Dense matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Parameters

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

Note

• # of computation: M*N
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

max() [2/256]

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

max() [3/256]

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

max() [4/256]

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

max() [5/256]

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

max() [6/256]

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

max() [7/256]

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

max() [8/256]

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

max() [9/256]

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

max() [10/256]

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

max() [11/256]

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

max() [12/256]

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

max() [13/256]

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

max() [14/256]

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

max() [15/256]

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

max() [16/256]

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

max() [17/256]

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

max() [18/256]

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

max() [19/256]

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

max() [20/256]

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

max() [21/256]

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

max() [22/256]

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

max() [23/256]

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

max() [24/256]

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

max() [25/256]

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

max() [26/256]

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

max() [27/256]

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

max() [28/256]

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

max() [29/256]

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

max() [30/256]

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

max() [31/256]

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

max() [32/256]

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

max() [33/256]

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

Create a new tensor_Dense tensor with greatest elements of two tensors (C[0:nnz] = max(A[0:nnz], B[0:nnz]))

Parameters

A	monolish tensor_Dense tensor
B	monolish tensor_Dense tensor
C	monolish tensor_Dense tensor

Note

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

max() [34/256]

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

max() [35/256]

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

max() [36/256]

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

max() [37/256]

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

max() [38/256]

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

max() [39/256]

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

max() [40/256]

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

max() [41/256]

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

max() [42/256]

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

max() [43/256]

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

max() [44/256]

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

max() [45/256]

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

max() [46/256]

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

max() [47/256]

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

max() [48/256]

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

max() [49/256]

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

max() [50/256]

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

max() [51/256]

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

max() [52/256]

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

max() [53/256]

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

max() [54/256]

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

max() [55/256]

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

max() [56/256]

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

max() [57/256]

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

max() [58/256]

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

max() [59/256]

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

max() [60/256]

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

max() [61/256]

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

max() [62/256]

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

max() [63/256]

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

max() [64/256]

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

max() [65/256]

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

max() [66/256]

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

max() [67/256]

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

max() [68/256]

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

max() [69/256]

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

max() [70/256]

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

max() [71/256]

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

max() [72/256]

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

max() [73/256]

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

max() [74/256]

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

max() [75/256]

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

max() [76/256]

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

max() [77/256]

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

max() [78/256]

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

max() [79/256]

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

max() [80/256]

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

max() [81/256]

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

max() [82/256]

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

max() [83/256]

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

max() [84/256]

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

max() [85/256]

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

max() [86/256]

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

max() [87/256]

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

max() [88/256]

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

max() [89/256]

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

max() [90/256]

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

max() [91/256]

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

max() [92/256]

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

max() [93/256]

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

max() [94/256]

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

max() [95/256]

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

max() [96/256]

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

max() [97/256]

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

max() [98/256]

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

max() [99/256]

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

max() [100/256]

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

max() [101/256]

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

max() [102/256]

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

max() [103/256]

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

max() [104/256]

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

max() [105/256]

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

max() [106/256]

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

max() [107/256]

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

max() [108/256]

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

max() [109/256]

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

max() [110/256]

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

max() [111/256]

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

max() [112/256]

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

max() [113/256]

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

max() [114/256]

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

max() [115/256]

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

max() [116/256]

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

max() [117/256]

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

max() [118/256]

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

max() [119/256]

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

max() [120/256]

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

max() [121/256]

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

max() [122/256]

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

max() [123/256]

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

max() [124/256]

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

max() [125/256]

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

max() [126/256]

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

max() [127/256]

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

max() [128/256]

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

max() [129/256]

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

max() [130/256]

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

max() [131/256]

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

max() [132/256]

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

max() [133/256]

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

max() [134/256]

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

max() [135/256]

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

max() [136/256]

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

max() [137/256]

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

max() [138/256]

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

max() [139/256]

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

max() [140/256]

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

max() [141/256]

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

max() [142/256]

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

max() [143/256]

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

max() [144/256]

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

max() [145/256]

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

max() [146/256]

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

max() [147/256]

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

max() [148/256]

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

max() [149/256]

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

max() [150/256]

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

max() [151/256]

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

max() [152/256]

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

max() [153/256]

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

max() [154/256]

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

max() [155/256]

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

max() [156/256]

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

max() [157/256]

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

max() [158/256]

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

max() [159/256]

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

max() [160/256]

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

max() [161/256]

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

max() [162/256]

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

max() [163/256]

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

max() [164/256]

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

max() [165/256]

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

max() [166/256]

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

max() [167/256]

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

max() [168/256]

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

max() [169/256]

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

max() [170/256]

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

max() [171/256]

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

max() [172/256]

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

max() [173/256]

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

max() [174/256]

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

max() [175/256]

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

max() [176/256]

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

max() [177/256]

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

max() [178/256]

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

max() [179/256]

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

max() [180/256]

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

max() [181/256]

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

max() [182/256]

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

max() [183/256]

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

max() [184/256]

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

max() [185/256]

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

max() [186/256]

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

max() [187/256]

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

max() [188/256]

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

max() [189/256]

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

max() [190/256]

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

max() [191/256]

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

max() [192/256]

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

max() [193/256]

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

max() [194/256]

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

max() [195/256]

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

max() [196/256]

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

max() [197/256]

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

max() [198/256]

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

max() [199/256]

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

max() [200/256]

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

max() [201/256]

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

max() [202/256]

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

max() [203/256]

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

max() [204/256]

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

max() [205/256]

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

max() [206/256]

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

max() [207/256]

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

max() [208/256]

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

max() [209/256]

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

max() [210/256]

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

max() [211/256]

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

max() [212/256]

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

max() [213/256]

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

max() [214/256]

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

max() [215/256]

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

max() [216/256]

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

max() [217/256]

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

max() [218/256]

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

max() [219/256]

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

max() [220/256]

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

max() [221/256]

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

max() [222/256]

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

max() [223/256]

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

max() [224/256]

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

max() [225/256]

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

max() [226/256]

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

max() [227/256]

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

max() [228/256]

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

max() [229/256]

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

max() [230/256]

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

max() [231/256]

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

max() [232/256]

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

max() [233/256]

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

max() [234/256]

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

max() [235/256]

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

max() [236/256]

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

max() [237/256]

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

max() [238/256]

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

max() [239/256]

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

max() [240/256]

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

max() [241/256]

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

max() [242/256]

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

max() [243/256]

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

max() [244/256]

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

max() [245/256]

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

max() [246/256]

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

max() [247/256]

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

max() [248/256]

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

max() [249/256]

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

max() [250/256]

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

max() [251/256]

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

max() [252/256]

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

max() [253/256]

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

max() [254/256]

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

max() [255/256]

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

max() [256/256]

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