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

Go to the source code of this file.

Namespaces
	monolish
	monolish namespaces

	monolish::blas
	Basic Linear Algebra Subprograms for Dense Matrix, Sparse Matrix, Vector and Scalar.

Functions
void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified col of dense matrix and vector adds: C[i][num] = A[i][num] + x[i]. More...

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[i]. More...

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified row of dense matrix and vector adds: C[num][j] = A[num][j] + x[j]. More...

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector adds: C[i][j] = A[i][j] + x[j]. More...

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::adds_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = aAx + by. More...

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	Dense matrix and vector multiplication: y = aAx + by. More...

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const vector< double > &x, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = Ax. More...

void	monolish::blas::matvec (const matrix::CRS< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const vector< double > &x, vector< double > &y)
	Dense matrix and vector multiplication: y = Ax. More...

void	monolish::blas::matvec (const matrix::Dense< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, vector< double > &y)
	matrix (LinearOperator) and vector multiplication: y = Ax More...

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = aA^N x + by. More...

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	Dense matrix and vector multiplication: y = aA^N x + by. More...

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const vector< double > &x, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = A^N x. More...

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const vector< double > &x, vector< double > &y)
	Dense matrix and vector multiplication: y = A^N x. More...

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_N (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = aA^T x + by. More...

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, vector< double > &y)
	Dense matrix and vector multiplication: y = aA^T x + by. More...

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const vector< double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, vector< double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const double &a, const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const double &b, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const vector< float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, vector< float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const float &a, const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const float &b, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const vector< double > &x, vector< double > &y)
	CRS format sparse matrix and vector multiplication: y = A^T x. More...

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const vector< double > &x, vector< double > &y)
	Dense matrix and vector multiplication: y = A^T x. More...

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::matvec_T (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, vector< double > &y)
	Adjoint LinearOperator matrix and vector multiplication: y = A^Hx. More...

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const vector< double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, vector< double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, vector< double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< tensor::tensor_Dense< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, vector< float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const vector< float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, vector< float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, vector< float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< tensor::tensor_Dense< float >, float > &y)

void	monolish::blas::rmatvec (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)

void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const vector< double > &x, matrix::CRS< double > &C)
	Specified col of CRS matrix and vector times: C[i][num] = A[i][num] * x[i]. More...

void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_col (const matrix::CRS< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_col (const matrix::CRS< double > &A, const vector< double > &x, matrix::CRS< double > &C)
	Column-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[i]. More...

void	monolish::blas::times_col (const matrix::CRS< double > &A, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_col (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const vector< float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const vector< float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified col of dense matrix and vector times: C[i][num] = A[i][num] * x[i]. More...

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Column-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[i]. More...

void	monolish::blas::times_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_col (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const vector< double > &x, matrix::CRS< double > &C)
	Specified row of CRS matrix and vector times: C[num][j] = A[num][j] * x[j]. More...

void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_row (const matrix::CRS< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_row (const matrix::CRS< double > &A, const vector< double > &x, matrix::CRS< double > &C)
	Row-wise CRS matrix and vector times: C[i][j] = A[i][j] * x[j]. More...

void	monolish::blas::times_row (const matrix::CRS< double > &A, const view1D< matrix::CRS< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_row (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, matrix::CRS< double > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const vector< float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const vector< float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const view1D< matrix::CRS< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, matrix::CRS< float > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)
	Specified row of dense matrix and vector times: C[num][j] = A[num][j] * x[j]. More...

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const vector< double > &x, matrix::Dense< double > &C)
	Row-wise Dense matrix and vector times: C[i][j] = A[i][j] * x[j]. More...

void	monolish::blas::times_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< matrix::Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< tensor::tensor_Dense< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const size_t num, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const vector< double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< matrix::Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< tensor::tensor_Dense< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, matrix::Dense< double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< matrix::Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< tensor::tensor_Dense< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< double >, double > &A, const view1D< vector< double >, double > &x, view_Dense< vector< double >, double > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const size_t num, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const vector< float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< matrix::Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< tensor::tensor_Dense< float >, float > &x, view_Dense< vector< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< matrix::Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< tensor::tensor_Dense< float >, float > &C)

void	monolish::blas::times_row (const view_Dense< vector< float >, float > &A, const view1D< vector< float >, float > &x, view_Dense< vector< float >, float > &C)

Namespaces

Functions