monolish::blas::times

element by element multiplication More...

Functions
void	monolish::blas::times (const double alpha, const matrix::CRS< double > &A, matrix::CRS< double > &C)
	CRS matrix times: C = alpha * A. More...
void	monolish::blas::times (const double alpha, const matrix::Dense< double > &A, matrix::Dense< double > &C)
	Dense matrix times: C = alpha * A. More...
void	monolish::blas::times (const double alpha, const vector< double > &a, vector< double > &y)
	element by element multiplication: y[i] = alpha * a[i] More...
void	monolish::blas::times (const double alpha, const vector< double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const vector< double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, vector< double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< matrix::Dense< double >, double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, vector< double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const double alpha, const view1D< vector< double >, double > &a, view1D< vector< double >, double > &y)
void	monolish::blas::times (const float alpha, const matrix::CRS< float > &A, matrix::CRS< float > &C)
void	monolish::blas::times (const float alpha, const matrix::Dense< float > &A, matrix::Dense< float > &C)
void	monolish::blas::times (const float alpha, const vector< float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const vector< float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const vector< float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< matrix::Dense< float >, float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, vector< float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const float alpha, const view1D< vector< float >, float > &a, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, vector< double > &y)
	element by element multiplication: y[i] = a[i] * b[i] More...
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const vector< double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const vector< float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< matrix::Dense< float >, float > &a, const view1D< vector< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const vector< double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< matrix::Dense< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, vector< double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< matrix::Dense< double >, double > &y)
void	monolish::blas::times (const view1D< vector< double >, double > &a, const view1D< vector< double >, double > &b, view1D< vector< double >, double > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const vector< float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< matrix::Dense< float >, float > &b, view1D< vector< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, vector< float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, view1D< matrix::Dense< float >, float > &y)
void	monolish::blas::times (const view1D< vector< float >, float > &a, const view1D< vector< float >, float > &b, 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 row of CRS matrix and vector times: C[i][num] = A[i][num] * x[j]. 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[j]. 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[j]. More...
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< vector< double >, double > &x, matrix::Dense< 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 view1D< matrix::Dense< double >, double > &x, matrix::Dense< 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< 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 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< vector< float >, float > &x, matrix::Dense< 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 view1D< matrix::Dense< float >, float > &x, matrix::Dense< 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_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 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< vector< double >, double > &x, matrix::Dense< 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 view1D< matrix::Dense< double >, double > &x, matrix::Dense< 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< 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 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< vector< float >, float > &x, matrix::Dense< 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 view1D< matrix::Dense< float >, float > &x, matrix::Dense< float > &C)
void	monolish::blas::times_row (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, matrix::Dense< float > &C)

Detailed Description

element by element multiplication

Function Documentation

times() [1/76]

void monolish::blas::times	(	const double	alpha,
		const matrix::CRS< double > &	A,
		matrix::CRS< double > &	C
	)

CRS matrix times: C = alpha * A.

Parameters

alpha	scalar value
A	CRS matrix (size M x N)
C	CRS matrix (size M x N)

Note

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

Warning

A, B, and C must be same non-zero structure

times() [2/76]

void monolish::blas::times	(	const double	alpha,
		const matrix::Dense< double > &	A,
		matrix::Dense< double > &	C
	)

Dense matrix times: C = alpha * A.

Parameters

alpha	scalar value
A	Dense matrix (size M x N)
C	Dense matrix (size M x N)

Note

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

times() [3/76]

void monolish::blas::times	(	const double	alpha,
		const vector< double > &	a,
		vector< double > &	y
	)

element by element multiplication: y[i] = alpha * a[i]

Parameters

alpha	scalar value
x	monolish vector (size N)
y	monolish vector (size N)

Note

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

times() [4/76]

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

times() [5/76]

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

times() [6/76]

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

times() [7/76]

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

times() [8/76]

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

times() [9/76]

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

times() [10/76]

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

times() [11/76]

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

times() [12/76]

void monolish::blas::times	(	const float	alpha,
		const matrix::CRS< float > &	A,
		matrix::CRS< float > &	C
	)

times() [13/76]

void monolish::blas::times	(	const float	alpha,
		const matrix::Dense< float > &	A,
		matrix::Dense< float > &	C
	)

times() [14/76]

void monolish::blas::times	(	const float	alpha,
		const vector< float > &	a,
		vector< float > &	y
	)

times() [15/76]

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

times() [16/76]

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

times() [17/76]

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

times() [18/76]

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

times() [19/76]

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

times() [20/76]

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

times() [21/76]

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

times() [22/76]

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

times() [23/76]

void monolish::blas::times	(	const vector< double > &	a,
		const vector< double > &	b,
		vector< double > &	y
	)

element by element multiplication: y[i] = a[i] * b[i]

Parameters

a	monolish vector (size N)
b	monolish vector (size N)
y	monolish vector (size N)

Note

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

times() [24/76]

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

times() [25/76]

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

times() [26/76]

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

times() [27/76]

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

times() [28/76]

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

times() [29/76]

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

times() [30/76]

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

times() [31/76]

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

times() [32/76]

void monolish::blas::times	(	const vector< float > &	a,
		const vector< float > &	b,
		vector< float > &	y
	)

times() [33/76]

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

times() [34/76]

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

times() [35/76]

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

times() [36/76]

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

times() [37/76]

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

times() [38/76]

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

times() [39/76]

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

times() [40/76]

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

times() [41/76]

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

times() [42/76]

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

times() [43/76]

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

times() [44/76]

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

times() [45/76]

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

times() [46/76]

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

times() [47/76]

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

times() [48/76]

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

times() [49/76]

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

times() [50/76]

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

times() [51/76]

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

times() [52/76]

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

times() [53/76]

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

times() [54/76]

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

times() [55/76]

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

times() [56/76]

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

times() [57/76]

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

times() [58/76]

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

times() [59/76]

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

times() [60/76]

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

times() [61/76]

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

times() [62/76]

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

times() [63/76]

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

times() [64/76]

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

times() [65/76]

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

times() [66/76]

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

times() [67/76]

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

times() [68/76]

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

times() [69/76]

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

times() [70/76]

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

times() [71/76]

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

times() [72/76]

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

times() [73/76]

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

times() [74/76]

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

times() [75/76]

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

times() [76/76]

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

times_col() [1/24]

void monolish::blas::times_col	(	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[i][num] = A[i][num] * x[j].

Parameters

A	CRS matrix (size M x N)
num	column number
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

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

Warning

A and C must be same non-zero structure

times_col() [2/24]

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
	)

times_col() [3/24]

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

times_col() [4/24]

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[j].

Parameters

A	CRS matrix (size M x N)
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

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

Warning

A and C must be same non-zero structure

times_col() [5/24]

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

times_col() [6/24]

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

times_col() [7/24]

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

times_col() [8/24]

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
	)

times_col() [9/24]

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

times_col() [10/24]

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

times_col() [11/24]

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

times_col() [12/24]

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

times_col() [13/24]

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[j].

Parameters

A	Dense matrix (size M x N)
num	column number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

times_col() [14/24]

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
	)

times_col() [15/24]

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

times_col() [16/24]

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].

Parameters

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

Note

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

times_col() [17/24]

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

times_col() [18/24]

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

times_col() [19/24]

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

times_col() [20/24]

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
	)

times_col() [21/24]

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

times_col() [22/24]

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

times_col() [23/24]

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

times_col() [24/24]

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

times_row() [1/24]

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].

Parameters

A	CRS matrix (size M x N)
num	row number
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

• # of computation: nnz of specified row
• Multi-threading: true
• GPU acceleration: true
  • # of data transfer: 0

Warning

A and C must be same non-zero structure

times_row() [2/24]

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
	)

times_row() [3/24]

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

times_row() [4/24]

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].

Parameters

A	CRS matrix (size M x N)
x	monolish vector (size M)
C	CRS matrix (size M x N)

Note

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

Warning

A and C must be same non-zero structure

times_row() [5/24]

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

times_row() [6/24]

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

times_row() [7/24]

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

times_row() [8/24]

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
	)

times_row() [9/24]

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

times_row() [10/24]

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

times_row() [11/24]

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

times_row() [12/24]

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

times_row() [13/24]

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].

Parameters

A	Dense matrix (size M x N)
num	row number
x	monolish vector (size M)
C	Dense matrix (size M x N)

Note

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

times_row() [14/24]

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
	)

times_row() [15/24]

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

times_row() [16/24]

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].

Parameters

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

Note

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

times_row() [17/24]

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

times_row() [18/24]

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

times_row() [19/24]

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

times_row() [20/24]

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
	)

times_row() [21/24]

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

times_row() [22/24]

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

times_row() [23/24]

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

times_row() [24/24]

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