monolish  0.14.0
MONOlithic LIner equation Solvers for Highly-parallel architecture
Namespaces | Functions
monolish_vector_blas.hpp File Reference
#include "../common/monolish_common.hpp"

Go to the source code of this file.

Namespaces

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

Functions

double monolish::blas::asum (const vector< double > &x)
 vector<float> asum (absolute sum) More...
 
void monolish::blas::asum (const vector< double > &x, double &ans)
 vector<float> asum (absolute sum) More...
 
float monolish::blas::asum (const vector< float > &x)
 
void monolish::blas::asum (const vector< float > &x, float &ans)
 
double monolish::blas::asum (const view1D< matrix::Dense< double >, double > &x)
 
void monolish::blas::asum (const view1D< matrix::Dense< double >, double > &x, double &ans)
 
float monolish::blas::asum (const view1D< matrix::Dense< float >, float > &x)
 
void monolish::blas::asum (const view1D< matrix::Dense< float >, float > &x, float &ans)
 
double monolish::blas::asum (const view1D< vector< double >, double > &x)
 
void monolish::blas::asum (const view1D< vector< double >, double > &x, double &ans)
 
float monolish::blas::asum (const view1D< vector< float >, float > &x)
 
void monolish::blas::asum (const view1D< vector< float >, float > &x, float &ans)
 
void monolish::blas::axpy (const double alpha, const vector< double > &x, vector< double > &y)
 axpy: y = ax + y More...
 
void monolish::blas::axpy (const double alpha, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::axpy (const double alpha, const vector< double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< vector< double >, double > &x, vector< double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::axpy (const double alpha, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::axpy (const float alpha, const vector< float > &x, vector< float > &y)
 
void monolish::blas::axpy (const float alpha, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::axpy (const float alpha, const vector< float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< vector< float >, float > &x, vector< float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::axpy (const float alpha, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const vector< double > &y, vector< double > &z)
 axpyz: z = ax + y More...
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const vector< double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const vector< double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, vector< double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, view1D< matrix::Dense< double >, double > &z)
 
void monolish::blas::axpyz (const double alpha, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, view1D< vector< double >, double > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const vector< float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const vector< float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const vector< float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, vector< float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, view1D< matrix::Dense< float >, float > &z)
 
void monolish::blas::axpyz (const float alpha, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, view1D< vector< float >, float > &z)
 
void monolish::blas::copy (const vector< double > &x, vector< double > &y)
 vector<float> copy (y=a) More...
 
void monolish::blas::copy (const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::copy (const vector< double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::copy (const vector< float > &x, vector< float > &y)
 
void monolish::blas::copy (const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::copy (const vector< float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::copy (const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::copy (const view1D< vector< double >, double > &x, vector< double > &y)
 
void monolish::blas::copy (const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::copy (const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::copy (const view1D< vector< float >, float > &x, vector< float > &y)
 
void monolish::blas::copy (const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::copy (const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)
 
double monolish::blas::dot (const vector< double > &x, const vector< double > &y)
 inner product (dot) More...
 
void monolish::blas::dot (const vector< double > &x, const vector< double > &y, double &ans)
 inner product (dot) More...
 
double monolish::blas::dot (const vector< double > &x, const view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::dot (const vector< double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
 
double monolish::blas::dot (const vector< double > &x, const view1D< vector< double >, double > &y)
 
void monolish::blas::dot (const vector< double > &x, const view1D< vector< double >, double > &y, double &ans)
 
float monolish::blas::dot (const vector< float > &x, const vector< float > &y)
 
void monolish::blas::dot (const vector< float > &x, const vector< float > &y, float &ans)
 
float monolish::blas::dot (const vector< float > &x, const view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::dot (const vector< float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
 
float monolish::blas::dot (const vector< float > &x, const view1D< vector< float >, float > &y)
 
void monolish::blas::dot (const vector< float > &x, const view1D< vector< float >, float > &y, float &ans)
 
double monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const vector< double > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const vector< double > &y, double &ans)
 
double monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
 
double monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y, double &ans)
 
float monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const vector< float > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const vector< float > &y, float &ans)
 
float monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
 
float monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y)
 
void monolish::blas::dot (const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y, float &ans)
 
double monolish::blas::dot (const view1D< vector< double >, double > &x, const vector< double > &y)
 
void monolish::blas::dot (const view1D< vector< double >, double > &x, const vector< double > &y, double &ans)
 
double monolish::blas::dot (const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::dot (const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y, double &ans)
 
double monolish::blas::dot (const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y)
 
void monolish::blas::dot (const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y, double &ans)
 
float monolish::blas::dot (const view1D< vector< float >, float > &x, const vector< float > &y)
 
void monolish::blas::dot (const view1D< vector< float >, float > &x, const vector< float > &y, float &ans)
 
float monolish::blas::dot (const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::dot (const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y, float &ans)
 
float monolish::blas::dot (const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y)
 
void monolish::blas::dot (const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y, float &ans)
 
double monolish::blas::nrm1 (const vector< double > &x)
 nrm1: sum(abs(x[0:N])) More...
 
void monolish::blas::nrm1 (const vector< double > &x, double &ans)
 nrm1: sum(abs(x[0:N])) More...
 
float monolish::blas::nrm1 (const vector< float > &x)
 
void monolish::blas::nrm1 (const vector< float > &x, float &ans)
 
double monolish::blas::nrm1 (const view1D< matrix::Dense< double >, double > &x)
 
void monolish::blas::nrm1 (const view1D< matrix::Dense< double >, double > &x, double &ans)
 
float monolish::blas::nrm1 (const view1D< matrix::Dense< float >, float > &x)
 
void monolish::blas::nrm1 (const view1D< matrix::Dense< float >, float > &x, float &ans)
 
double monolish::blas::nrm1 (const view1D< vector< double >, double > &x)
 
void monolish::blas::nrm1 (const view1D< vector< double >, double > &x, double &ans)
 
float monolish::blas::nrm1 (const view1D< vector< float >, float > &x)
 
void monolish::blas::nrm1 (const view1D< vector< float >, float > &x, float &ans)
 
double monolish::blas::nrm2 (const vector< double > &x)
 nrm2: ||x||_2 More...
 
void monolish::blas::nrm2 (const vector< double > &x, double &ans)
 nrm2: ||x||_2 More...
 
float monolish::blas::nrm2 (const vector< float > &x)
 
void monolish::blas::nrm2 (const vector< float > &x, float &ans)
 
double monolish::blas::nrm2 (const view1D< matrix::Dense< double >, double > &x)
 
void monolish::blas::nrm2 (const view1D< matrix::Dense< double >, double > &x, double &ans)
 
float monolish::blas::nrm2 (const view1D< matrix::Dense< float >, float > &x)
 
void monolish::blas::nrm2 (const view1D< matrix::Dense< float >, float > &x, float &ans)
 
double monolish::blas::nrm2 (const view1D< vector< double >, double > &x)
 
void monolish::blas::nrm2 (const view1D< vector< double >, double > &x, double &ans)
 
float monolish::blas::nrm2 (const view1D< vector< float >, float > &x)
 
void monolish::blas::nrm2 (const view1D< vector< float >, float > &x, float &ans)
 
void monolish::blas::scal (const double alpha, vector< double > &x)
 scal: x = alpha * x More...
 
void monolish::blas::scal (const double alpha, view1D< matrix::Dense< double >, double > &x)
 
void monolish::blas::scal (const double alpha, view1D< vector< double >, double > &x)
 
void monolish::blas::scal (const float alpha, vector< float > &x)
 
void monolish::blas::scal (const float alpha, view1D< matrix::Dense< float >, float > &x)
 
void monolish::blas::scal (const float alpha, view1D< vector< float >, float > &x)
 
double monolish::blas::sum (const vector< double > &x)
 vector<float> sum More...
 
void monolish::blas::sum (const vector< double > &x, double &ans)
 vector<float> sum More...
 
float monolish::blas::sum (const vector< float > &x)
 
void monolish::blas::sum (const vector< float > &x, float &ans)
 
double monolish::blas::sum (const view1D< matrix::Dense< double >, double > &x)
 
void monolish::blas::sum (const view1D< matrix::Dense< double >, double > &x, double &ans)
 
float monolish::blas::sum (const view1D< matrix::Dense< float >, float > &x)
 
void monolish::blas::sum (const view1D< matrix::Dense< float >, float > &x, float &ans)
 
double monolish::blas::sum (const view1D< vector< double >, double > &x)
 
void monolish::blas::sum (const view1D< vector< double >, double > &x, double &ans)
 
float monolish::blas::sum (const view1D< vector< float >, float > &x)
 
void monolish::blas::sum (const view1D< vector< float >, float > &x, float &ans)
 
void monolish::blas::vecadd (const vector< double > &a, const vector< double > &b, vector< double > &y)
 element by element addition of vector a and vector b. More...
 
void monolish::blas::vecadd (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecadd (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const vector< double > &b, vector< double > &y)
 element by element subtract of vector a and vector b. More...
 
void monolish::blas::vecsub (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::vecsub (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
 
void monolish::blas::xpay (const double alpha, const vector< double > &x, vector< double > &y)
 xpay: y = x + ay More...
 
void monolish::blas::xpay (const double alpha, const vector< double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::xpay (const double alpha, const vector< double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, vector< double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< matrix::Dense< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< vector< double >, double > &x, vector< double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< vector< double >, double > &x, view1D< matrix::Dense< double >, double > &y)
 
void monolish::blas::xpay (const double alpha, const view1D< vector< double >, double > &x, view1D< vector< double >, double > &y)
 
void monolish::blas::xpay (const float alpha, const vector< float > &x, vector< float > &y)
 
void monolish::blas::xpay (const float alpha, const vector< float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::xpay (const float alpha, const vector< float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, vector< float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< matrix::Dense< float >, float > &x, view1D< vector< float >, float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< vector< float >, float > &x, vector< float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< vector< float >, float > &x, view1D< matrix::Dense< float >, float > &y)
 
void monolish::blas::xpay (const float alpha, const view1D< vector< float >, float > &x, view1D< vector< float >, float > &y)