monolish::vml::min

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

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

Detailed Description

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

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

Function Documentation

min() [1/256]

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

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

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

min() [2/256]

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

min() [3/256]

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

min() [4/256]

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

min() [5/256]

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

min() [6/256]

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

min() [7/256]

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

min() [8/256]

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

min() [9/256]

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

min() [10/256]

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

min() [11/256]

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

min() [12/256]

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

min() [13/256]

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

min() [14/256]

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

min() [15/256]

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

min() [16/256]

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

min() [17/256]

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

min() [18/256]

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

min() [19/256]

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

min() [20/256]

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

min() [21/256]

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

min() [22/256]

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

min() [23/256]

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

min() [24/256]

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

min() [25/256]

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

min() [26/256]

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

min() [27/256]

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

min() [28/256]

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

min() [29/256]

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

min() [30/256]

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

min() [31/256]

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

min() [32/256]

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

min() [33/256]

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

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

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

min() [34/256]

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

min() [35/256]

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

min() [36/256]

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

min() [37/256]

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

min() [38/256]

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

min() [39/256]

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

min() [40/256]

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

min() [41/256]

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

min() [42/256]

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

min() [43/256]

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

min() [44/256]

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

min() [45/256]

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

min() [46/256]

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

min() [47/256]

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

min() [48/256]

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

min() [49/256]

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

min() [50/256]

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

min() [51/256]

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

min() [52/256]

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

min() [53/256]

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

min() [54/256]

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

min() [55/256]

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

min() [56/256]

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

min() [57/256]

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

min() [58/256]

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

min() [59/256]

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

min() [60/256]

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

min() [61/256]

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

min() [62/256]

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

min() [63/256]

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

min() [64/256]

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

min() [65/256]

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

min() [66/256]

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

min() [67/256]

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

min() [68/256]

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

min() [69/256]

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

min() [70/256]

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

min() [71/256]

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

min() [72/256]

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

min() [73/256]

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

min() [74/256]

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

min() [75/256]

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

min() [76/256]

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

min() [77/256]

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

min() [78/256]

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

min() [79/256]

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

min() [80/256]

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

min() [81/256]

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

min() [82/256]

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

min() [83/256]

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

min() [84/256]

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

min() [85/256]

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

min() [86/256]

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

min() [87/256]

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

min() [88/256]

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

min() [89/256]

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

min() [90/256]

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

min() [91/256]

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

min() [92/256]

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

min() [93/256]

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

min() [94/256]

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

min() [95/256]

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

min() [96/256]

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

min() [97/256]

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

min() [98/256]

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

min() [99/256]

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

min() [100/256]

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

min() [101/256]

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

min() [102/256]

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

min() [103/256]

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

min() [104/256]

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

min() [105/256]

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

min() [106/256]

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

min() [107/256]

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

min() [108/256]

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

min() [109/256]

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

min() [110/256]

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

min() [111/256]

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

min() [112/256]

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

min() [113/256]

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

min() [114/256]

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

min() [115/256]

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

min() [116/256]

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

min() [117/256]

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

min() [118/256]

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

min() [119/256]

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

min() [120/256]

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

min() [121/256]

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

min() [122/256]

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

min() [123/256]

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

min() [124/256]

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

min() [125/256]

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

min() [126/256]

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

min() [127/256]

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

min() [128/256]

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

min() [129/256]

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

min() [130/256]

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

min() [131/256]

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

min() [132/256]

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

min() [133/256]

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

min() [134/256]

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

min() [135/256]

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

min() [136/256]

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

min() [137/256]

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

min() [138/256]

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

min() [139/256]

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

min() [140/256]

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

min() [141/256]

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

min() [142/256]

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

min() [143/256]

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

min() [144/256]

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

min() [145/256]

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

min() [146/256]

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

min() [147/256]

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

min() [148/256]

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

min() [149/256]

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

min() [150/256]

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

min() [151/256]

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

min() [152/256]

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

min() [153/256]

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

min() [154/256]

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

min() [155/256]

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

min() [156/256]

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

min() [157/256]

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

min() [158/256]

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

min() [159/256]

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

min() [160/256]

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

min() [161/256]

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

min() [162/256]

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

min() [163/256]

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

min() [164/256]

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

min() [165/256]

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

min() [166/256]

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

min() [167/256]

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

min() [168/256]

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

min() [169/256]

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

min() [170/256]

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

min() [171/256]

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

min() [172/256]

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

min() [173/256]

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

min() [174/256]

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

min() [175/256]

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

min() [176/256]

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

min() [177/256]

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

min() [178/256]

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

min() [179/256]

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

min() [180/256]

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

min() [181/256]

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

min() [182/256]

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

min() [183/256]

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

min() [184/256]

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

min() [185/256]

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

min() [186/256]

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

min() [187/256]

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

min() [188/256]

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

min() [189/256]

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

min() [190/256]

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

min() [191/256]

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

min() [192/256]

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

min() [193/256]

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

min() [194/256]

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

min() [195/256]

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

min() [196/256]

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

min() [197/256]

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

min() [198/256]

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

min() [199/256]

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

min() [200/256]

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

min() [201/256]

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

min() [202/256]

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

min() [203/256]

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

min() [204/256]

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

min() [205/256]

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

min() [206/256]

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

min() [207/256]

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

min() [208/256]

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

min() [209/256]

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

min() [210/256]

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

min() [211/256]

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

min() [212/256]

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

min() [213/256]

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

min() [214/256]

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

min() [215/256]

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

min() [216/256]

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

min() [217/256]

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

min() [218/256]

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

min() [219/256]

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

min() [220/256]

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

min() [221/256]

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

min() [222/256]

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

min() [223/256]

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

min() [224/256]

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

min() [225/256]

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

min() [226/256]

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

min() [227/256]

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

min() [228/256]

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

min() [229/256]

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

min() [230/256]

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

min() [231/256]

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

min() [232/256]

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

min() [233/256]

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

min() [234/256]

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

min() [235/256]

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

min() [236/256]

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

min() [237/256]

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

min() [238/256]

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

min() [239/256]

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

min() [240/256]

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

min() [241/256]

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

min() [242/256]

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

min() [243/256]

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

min() [244/256]

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

min() [245/256]

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

min() [246/256]

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

min() [247/256]

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

min() [248/256]

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

min() [249/256]

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

min() [250/256]

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

min() [251/256]

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

min() [252/256]

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

min() [253/256]

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

min() [254/256]

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

min() [255/256]

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

min() [256/256]

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