monolish utilities More...

Functions
template<typename T >
matrix::COO< T >	band_matrix (const int M, const int N, const int W, const T diag_val, const T val)
	create band matrix More...

bool	build_with_avx ()
	get build option (true: with avx, false: without avx) More...

bool	build_with_avx2 ()
	get build option (true: with avx2, false: without avx2) More...

bool	build_with_avx512 ()
	get build option (true: with avx512, false: without avx512) More...

bool	build_with_cblas ()
	get build option (true: with cblas, false: without cblas (=with intel mkl)) More...

bool	build_with_gpu ()
	get build option (true: enable gpu, false: disable gpu) More...

bool	build_with_lapack ()
	get build option (true: with lapack, false: without lapack (=with intel mkl)) More...

bool	build_with_mkl ()
	get build option (true: with intel mkl, false: without intel mkl) More...

bool	build_with_mpi ()
	get build option (true: enable MPI, false: disable MPI) More...

template<typename T >
auto	device_free (T &x)
	free data of GPU More...

template<typename T , typename... Types>
auto	device_free (T &x, Types &... args)
	free datas of GPU More...

template<typename T >
matrix::COO< T >	eye (const int M)
	create band matrix More...

template<typename T >
matrix::COO< T >	frank_matrix (const int &M)
	create Frank matrix More...

template<typename T >
T	frank_matrix_eigenvalue (const int &M, const int &N)
	Nth eigenvalue from the bottom of MxM Frank matrix. More...

int	get_default_device ()
	get default device number More...

int	get_num_devices ()
	get the number of devices More...

double	get_residual_l2 (const matrix::CRS< double > &A, const vector< double > &x, const vector< double > &y)
	get nrm \|b-Ax\|_2 More...

double	get_residual_l2 (const matrix::CRS< double > &A, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const vector< double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::CRS< double > &A, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const vector< float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const vector< float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::CRS< float > &A, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const vector< double > &x, const vector< double > &y)
	get nrm \|b-Ax\|_2 More...

double	get_residual_l2 (const matrix::Dense< double > &A, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const vector< double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::Dense< double > &A, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const vector< float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const vector< float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::Dense< float > &A, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const vector< double > &x, const vector< double > &y)
	get nrm \|b-Ax\|_2 More...

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const vector< double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const vector< double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< matrix::Dense< double >, double > &x, const view1D< vector< double >, double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, const vector< double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, const view1D< matrix::Dense< double >, double > &y)

double	get_residual_l2 (const matrix::LinearOperator< double > &A, const view1D< vector< double >, double > &x, const view1D< vector< double >, double > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const vector< float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const vector< float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const vector< float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< matrix::Dense< float >, float > &x, const view1D< vector< float >, float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, const vector< float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, const view1D< matrix::Dense< float >, float > &y)

float	get_residual_l2 (const matrix::LinearOperator< float > &A, const view1D< vector< float >, float > &x, const view1D< vector< float >, float > &y)

template<typename T , typename U >
bool	is_same_device_mem_stat (const T &arg1, const U &arg2)
	compare same device memory status More...

template<typename T , typename U , typename... types>
bool	is_same_device_mem_stat (const T &arg1, const U &arg2, const types &... args)
	compare same device memory status More...

template<typename T >
bool	is_same_size (const matrix::COO< T > &A, const matrix::COO< T > &B)
	compare row and col size More...

template<typename T >
bool	is_same_size (const matrix::CRS< T > &A, const matrix::CRS< T > &B)
	compare row and col size More...

template<typename T >
bool	is_same_size (const matrix::Dense< T > &A, const matrix::Dense< T > &B)
	compare row and col size More...

template<typename T >
bool	is_same_size (const matrix::LinearOperator< T > &A, const matrix::LinearOperator< T > &B)
	compare row and col size More...

template<typename T , typename U , typename... types>
bool	is_same_size (const T &arg1, const U &arg2, const types &... args)
	compare matrix size More...

template<typename T , typename U >
bool	is_same_size (const T &x, const U &y)
	compare size of vector or 1Dview (same as is_same_structure()) More...

template<typename T >
bool	is_same_structure (const matrix::COO< T > &A, const matrix::COO< T > &B)
	compare structure using col_index and row_index, M, and N More...

template<typename T >
bool	is_same_structure (const matrix::CRS< T > &A, const matrix::CRS< T > &B)
	compare structure using structure_hash, M, and N More...

template<typename T >
bool	is_same_structure (const matrix::Dense< T > &A, const matrix::Dense< T > &B)
	compare structure using M and N (same as is_same_size()) More...

template<typename T >
bool	is_same_structure (const matrix::LinearOperator< T > &A, const matrix::LinearOperator< T > &B)
	compare structure using M and N (same as is_same_size()) More...

template<typename T , typename... types>
bool	is_same_structure (const T &A, const T &B, const types &... args)
	compare matrix structure More...

template<typename T , typename U >
bool	is_same_structure (const T A, const U B)
	compare matrix structure More...

template<typename T >
bool	is_same_structure (const vector< T > &x, const vector< T > &y)
	compare structure of vector (same as is_same_size()) More...

template<typename T >
matrix::COO< T >	laplacian_matrix_1D (const int &M)
	create 1D Laplacian matrix More...

template<typename T >
T	laplacian_matrix_1D_eigenvalue (const int &M, int N)
	Nth smallest eigenvalue of 1D Laplacian matrix. More...

template<typename T >
matrix::COO< T >	laplacian_matrix_2D_5p (const int M, const int N)
	create two dimensional Laplacian matrix using the five point central difference scheme More...

template<typename T >
matrix::COO< T >	random_structure_matrix (const int M, const int N, const int nnzrow, const T val)
	create random structure matrix (column number is decided by random) More...

template<typename T >
void	random_vector (vector< T > &vec, const T min, const T max)
	create random vector More...

template<typename T >
auto	recv (T &x)
	recv. and free data from GPU More...

template<typename T , typename... Types>
auto	recv (T &x, Types &... args)
	recv. and free datas to GPU More...

template<typename T >
auto	send (T &x)
	send data to GPU More...

template<typename T , typename... Types>
auto	send (T &x, Types &... args)
	send datas to GPU More...

bool	set_default_device (size_t device_num)
	set default device number More...

void	set_log_filename (const std::string filename)
	Specifying the log finename. More...

void	set_log_level (const size_t Level)
	Logger utils ///////////////////////////////. More...

bool	solver_check (const int err)
	check error More...

template<typename T >
matrix::COO< T >	toeplitz_plus_hankel_matrix (const int &M, T a0, T a1, T a2)
	create Toeplitz-plus-Hankel matrix More...

template<typename T >
T	toeplitz_plus_hankel_matrix_eigenvalue (const int &M, int N, T a0, T a1, T a2, T b0, T b1, T b2)
	Nth smallest eigenvalue of GEVP Ax=lBx of Toeplitz-plus-Hankel matrixes A, B. More...

template<typename T >
matrix::COO< T >	tridiagonal_toeplitz_matrix (const int &M, T a, T b)
	create tridiagonal Toeplitz matrix More...

template<typename T >
T	tridiagonal_toeplitz_matrix_eigenvalue (const int &M, int N, T a, T b)
	Nth smallest eigenvalue of MxM tridiagonal Toeplitz matrix. More...

Detailed Description

monolish utilities

Function Documentation

◆ band_matrix()

template<typename T >

matrix::COO<T> monolish::util::band_matrix	(	const int	M,
		const int	N,
		const int	W,
		const T	diag_val,
		const T	val
	)

create band matrix

Parameters

M	# of Row
N	# of col.
W	half-bandwidth (bandwidth is 2*W+1)
diag_val	value of diagonal elements
val	value of non-diagonal elements

Note

# of computation: M*W
Multi-threading: false
GPU acceleration: false

◆ build_with_avx()

bool monolish::util::build_with_avx ( )

get build option (true: with avx, false: without avx)

◆ build_with_avx2()

bool monolish::util::build_with_avx2 ( )

get build option (true: with avx2, false: without avx2)

◆ build_with_avx512()

bool monolish::util::build_with_avx512 ( )

get build option (true: with avx512, false: without avx512)

◆ build_with_cblas()

bool monolish::util::build_with_cblas ( )

get build option (true: with cblas, false: without cblas (=with intel mkl))

◆ build_with_gpu()

bool monolish::util::build_with_gpu ( )

get build option (true: enable gpu, false: disable gpu)

◆ build_with_lapack()

bool monolish::util::build_with_lapack ( )

get build option (true: with lapack, false: without lapack (=with intel mkl))

◆ build_with_mkl()

bool monolish::util::build_with_mkl ( )

get build option (true: with intel mkl, false: without intel mkl)

◆ build_with_mpi()

bool monolish::util::build_with_mpi ( )

get build option (true: enable MPI, false: disable MPI)

◆ device_free() [1/2]

template<typename T >

auto monolish::util::device_free ( T & x )

free data of GPU

Definition at line 671 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ device_free() [2/2]

template<typename T , typename... Types>

auto monolish::util::device_free	(	T &	x,
		Types &...	args
	)

free datas of GPU

Definition at line 677 of file monolish_common.hpp.

Here is the call graph for this function:

◆ eye()

template<typename T >

matrix::COO<T> monolish::util::eye ( const int M )

create band matrix

Parameters

M	# of Row and col.

Note

# of computation: M
Multi-threading: false
GPU acceleration: false

◆ frank_matrix()

template<typename T >

matrix::COO<T> monolish::util::frank_matrix ( const int & M )

create Frank matrix

Parameters

M	# of row and col

Note

# of computation: M^2
Multi-threading: false
GPU acceleration: false

◆ frank_matrix_eigenvalue()

template<typename T >

T monolish::util::frank_matrix_eigenvalue	(	const int &	M,
		const int &	N
	)

Nth eigenvalue from the bottom of MxM Frank matrix.

Parameters

M	dimension of Frank matrix
N	#-th eigenvalue from the bottom

Note

# of computation: O(1)
Multi-threading: false
GPU acceleration: false

◆ get_default_device()

int monolish::util::get_default_device ( )

get default device number

Returns: the device number (If the device is not found or the GPU is not enabled, return value is negative)

◆ get_num_devices()

int monolish::util::get_num_devices ( )

get the number of devices

Returns: the number of devices (If the device is not found or the GPU is not enabled, return value is negative)

◆ get_residual_l2() [1/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		const vector< double > &	y
	)

get nrm |b-Ax|_2

Parameters

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

Note

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

◆ get_residual_l2() [2/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [3/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [4/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [5/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [6/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [7/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [8/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [9/54]

double monolish::util::get_residual_l2	(	const matrix::CRS< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [10/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [11/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [12/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [13/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [14/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [15/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [16/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [17/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [18/54]

float monolish::util::get_residual_l2	(	const matrix::CRS< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [19/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		const vector< double > &	y
	)

get nrm |b-Ax|_2

Parameters

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

Note

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

◆ get_residual_l2() [20/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [21/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [22/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [23/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [24/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [25/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [26/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [27/54]

double monolish::util::get_residual_l2	(	const matrix::Dense< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [28/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [29/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [30/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [31/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [32/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [33/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [34/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [35/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [36/54]

float monolish::util::get_residual_l2	(	const matrix::Dense< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [37/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		const vector< double > &	y
	)

get nrm |b-Ax|_2

Parameters

A	LinearOperator (size M x N)
x	monolish vector (size N)
y	monolish vector (size M)

Note

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

◆ get_residual_l2() [38/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [39/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const vector< double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [40/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [41/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [42/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< matrix::Dense< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [43/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		const vector< double > &	y
	)

◆ get_residual_l2() [44/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< matrix::Dense< double >, double > &	y
	)

◆ get_residual_l2() [45/54]

double monolish::util::get_residual_l2	(	const matrix::LinearOperator< double > &	A,
		const view1D< vector< double >, double > &	x,
		const view1D< vector< double >, double > &	y
	)

◆ get_residual_l2() [46/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [47/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [48/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const vector< float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [49/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [50/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [51/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< matrix::Dense< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ get_residual_l2() [52/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		const vector< float > &	y
	)

◆ get_residual_l2() [53/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< matrix::Dense< float >, float > &	y
	)

◆ get_residual_l2() [54/54]

float monolish::util::get_residual_l2	(	const matrix::LinearOperator< float > &	A,
		const view1D< vector< float >, float > &	x,
		const view1D< vector< float >, float > &	y
	)

◆ is_same_device_mem_stat() [1/2]

template<typename T , typename U >

bool monolish::util::is_same_device_mem_stat	(	const T &	arg1,
		const U &	arg2
	)

compare same device memory status

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

Definition at line 454 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ is_same_device_mem_stat() [2/2]

template<typename T , typename U , typename... types>

bool monolish::util::is_same_device_mem_stat	(	const T &	arg1,
		const U &	arg2,
		const types &...	args
	)

compare same device memory status

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

Definition at line 466 of file monolish_common.hpp.

Here is the call graph for this function:

◆ is_same_size() [1/6]

template<typename T >

bool monolish::util::is_same_size	(	const matrix::COO< T > &	A,
		const matrix::COO< T > &	B
	)

compare row and col size

Parameters

A	COO matrix
B	COO matrix

Returns: true is same size

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_size() [2/6]

template<typename T >

bool monolish::util::is_same_size	(	const matrix::CRS< T > &	A,
		const matrix::CRS< T > &	B
	)

compare row and col size

Parameters

A	COO matrix
B	COO matrix

Returns: true is same size

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_size() [3/6]

template<typename T >

bool monolish::util::is_same_size	(	const matrix::Dense< T > &	A,
		const matrix::Dense< T > &	B
	)

compare row and col size

Parameters

A	Dense matrix
B	Dense matrix

Returns: true is same size

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_size() [4/6]

template<typename T >

bool monolish::util::is_same_size	(	const matrix::LinearOperator< T > &	A,
		const matrix::LinearOperator< T > &	B
	)

compare row and col size

Parameters

A	LinearOperator matrix
B	LinearOperator matrix

Returns: true is same size

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_size() [5/6]

template<typename T , typename U , typename... types>

bool monolish::util::is_same_size	(	const T &	arg1,
		const U &	arg2,
		const types &...	args
	)

compare matrix size

Definition at line 441 of file monolish_common.hpp.

Here is the call graph for this function:

◆ is_same_size() [6/6]

template<typename T , typename U >

bool monolish::util::is_same_size	(	const T &	x,
		const U &	y
	)

compare size of vector or 1Dview (same as is_same_structure())

Parameters

x	monolish vector
y	monolish vector

Returns: true is same size

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

Definition at line 377 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ is_same_structure() [1/7]

template<typename T >

bool monolish::util::is_same_structure	(	const matrix::COO< T > &	A,
		const matrix::COO< T > &	B
	)

compare structure using col_index and row_index, M, and N

Parameters

A	COO matrix
B	COO matrix

Returns: true is same structure

Note

# of computation: 2nnz
Multi-threading: false
GPU acceleration: false

◆ is_same_structure() [2/7]

template<typename T >

bool monolish::util::is_same_structure	(	const matrix::CRS< T > &	A,
		const matrix::CRS< T > &	B
	)

compare structure using structure_hash, M, and N

Parameters

A	CRS matrix
B	CRS matrix

Returns: true is same structure

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_structure() [3/7]

template<typename T >

bool monolish::util::is_same_structure	(	const matrix::Dense< T > &	A,
		const matrix::Dense< T > &	B
	)

compare structure using M and N (same as is_same_size())

Parameters

A	Dense matrix
B	Dense matrix

Returns: true is same structure

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_structure() [4/7]

template<typename T >

bool monolish::util::is_same_structure	(	const matrix::LinearOperator< T > &	A,
		const matrix::LinearOperator< T > &	B
	)

compare structure using M and N (same as is_same_size())

Parameters

A	LinearOperator matrix
B	LinearOperator matrix

Returns: true is same structure

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

◆ is_same_structure() [5/7]

template<typename T , typename... types>

bool monolish::util::is_same_structure	(	const T &	A,
		const T &	B,
		const types &...	args
	)

compare matrix structure

Definition at line 361 of file monolish_common.hpp.

Here is the call graph for this function:

◆ is_same_structure() [6/7]

template<typename T , typename U >

bool monolish::util::is_same_structure	(	const T	A,
		const U	B
	)

compare matrix structure

Definition at line 282 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ is_same_structure() [7/7]

template<typename T >

bool monolish::util::is_same_structure	(	const vector< T > &	x,
		const vector< T > &	y
	)

compare structure of vector (same as is_same_size())

Parameters

x	monolish vector
y	monolish vector

Returns: true is same structure

Note

# of computation: 1
Multi-threading: false
GPU acceleration: false

Definition at line 297 of file monolish_common.hpp.

Here is the call graph for this function:

◆ laplacian_matrix_1D()

template<typename T >

matrix::COO<T> monolish::util::laplacian_matrix_1D ( const int & M )

create 1D Laplacian matrix

Parameters

M	# of row and col

Note

# of computation: M
Multi-threading: false
GPU acceleration: false

◆ laplacian_matrix_1D_eigenvalue()

template<typename T >

T monolish::util::laplacian_matrix_1D_eigenvalue	(	const int &	M,
		int	N
	)

Nth smallest eigenvalue of 1D Laplacian matrix.

Parameters

M	dimension of tridiagonal Toeplitz matrix
N	#-th eigenvalue from the bottom

Note

# of computation: O(1)
Multi-threading: false
GPU acceleration: false

◆ laplacian_matrix_2D_5p()

template<typename T >

matrix::COO<T> monolish::util::laplacian_matrix_2D_5p	(	const int	M,
		const int	N
	)

create two dimensional Laplacian matrix using the five point central difference scheme

Parameters

M	# of grid point
N	# of grid point

Note

# of computation: N*M
Multi-threading: false
GPU acceleration: false

◆ random_structure_matrix()

template<typename T >

matrix::COO<T> monolish::util::random_structure_matrix	(	const int	M,
		const int	N,
		const int	nnzrow,
		const T	val
	)

create random structure matrix (column number is decided by random)

Parameters

M	# of Row
N	# of col.
nnzrow	non-zero elements per row
val	value of elements

Note

# of computation: M*nnzrow
Multi-threading: false
GPU acceleration: false

◆ random_vector()

template<typename T >

void monolish::util::random_vector	(	vector< T > &	vec,
		const T	min,
		const T	max
	)

create random vector

Parameters

vec	allocated vector
min	min. of random
max	min. of random

Note

the ramdom number generator is random generator is mt19937

# of computation: N
Multi-threading: true
GPU acceleration: false

◆ recv() [1/2]

template<typename T >

auto monolish::util::recv ( T & x )

recv. and free data from GPU

Definition at line 656 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ recv() [2/2]

template<typename T , typename... Types>

auto monolish::util::recv	(	T &	x,
		Types &...	args
	)

recv. and free datas to GPU

Definition at line 661 of file monolish_common.hpp.

Here is the call graph for this function:

◆ send() [1/2]

template<typename T >

auto monolish::util::send ( T & x )

send data to GPU

Definition at line 642 of file monolish_common.hpp.

Here is the caller graph for this function:

◆ send() [2/2]

template<typename T , typename... Types>

auto monolish::util::send	(	T &	x,
		Types &...	args
	)

send datas to GPU

Definition at line 647 of file monolish_common.hpp.

Here is the call graph for this function:

◆ set_default_device()

bool monolish::util::set_default_device ( size_t device_num )

set default device number

Returns: if the GPU is not enabled, return false

◆ set_log_filename()

void monolish::util::set_log_filename ( const std::string filename )

Specifying the log finename.

Parameters

filename the log filename

◆ set_log_level()

void monolish::util::set_log_level ( const size_t Level )

Logger utils ///////////////////////////////.

Specifying the log level

Parameters

Level loglevel

Note

loglevel is

logging solvers (CG, Jacobi, LU...etc.)
logging solvers and BLAS functions (matmul, matvec, arithmetic operators..etc.)
logging solvers and BLAS functions and utils (send, recv, allocation...etc.)

◆ solver_check()

bool monolish::util::solver_check ( const int err )

check error

Parameters

[in] err solver err code

Note

MONOLISH_SOLVER_SUCCESS 0
MONOLISH_SOLVER_SIZE_ERROR -1
MONOLISH_SOLVER_MAXITER -2
MONOLISH_SOLVER_BREAKDOWN -3
MONOLISH_SOLVER_RESIDUAL_NAN -4
MONOLISH_SOLVER_NOT_IMPL -10

◆ toeplitz_plus_hankel_matrix()

template<typename T >

matrix::COO<T> monolish::util::toeplitz_plus_hankel_matrix	(	const int &	M,
		T	a0,
		T	a1,
		T	a2
	)

create Toeplitz-plus-Hankel matrix

Parameters

M	# of row and col
a0	value of diagonal elements
a1	value of next-to-diagonal elements
a2	value of second-next-to-diagonal elements

Note

taken from arxiv:2007.08130
(0, 0) and (M-1, M-1) elements are modified to a0-a2
both A and B of the GEVP have same structure
Multi-threading: false
GPU acceleration: false

◆ toeplitz_plus_hankel_matrix_eigenvalue()

template<typename T >

T monolish::util::toeplitz_plus_hankel_matrix_eigenvalue	(	const int &	M,
		int	N,
		T	a0,
		T	a1,
		T	a2,
		T	b0,
		T	b1,
		T	b2
	)

Nth smallest eigenvalue of GEVP Ax=lBx of Toeplitz-plus-Hankel matrixes A, B.

Parameters

M	dimension of Toeplitz-plus-Hankel marices
N	#-th eigenvalue from the bottom
a0,a1,a2	value of Toeplitz-plus-Hankel matrix A
b0,b1,b2	value of TOeplitz-plus-Hankel matrix B

Note

# of computation: O(1)
Multi-threading: false
GPU acceleration: false

◆ tridiagonal_toeplitz_matrix()

template<typename T >

matrix::COO<T> monolish::util::tridiagonal_toeplitz_matrix	(	const int &	M,
		T	a,
		T	b
	)

create tridiagonal Toeplitz matrix

Parameters

M	# of row and col
a	value of diagonal elements
b	value of next-to-diagonal elements

Note

# of computation: M
Multi-threading: false
GPU acceleration: false

◆ tridiagonal_toeplitz_matrix_eigenvalue()

template<typename T >

T monolish::util::tridiagonal_toeplitz_matrix_eigenvalue	(	const int &	M,
		int	N,
		T	a,
		T	b
	)

Nth smallest eigenvalue of MxM tridiagonal Toeplitz matrix.

Parameters

M	dimension of tridiagonal Toeplitz matrix
N	#-th eigenvalue from the bottom
a	value of diagonal elements
b	value of next-to-diagonal elements

Note

# of computation: O(1)
Multi-threading: false
GPU acceleration: false

Functions

Detailed Description

Function Documentation

◆ band_matrix()

◆ build_with_avx()

◆ build_with_avx2()

◆ build_with_avx512()

◆ build_with_cblas()

◆ build_with_gpu()

◆ build_with_lapack()

◆ build_with_mkl()

◆ build_with_mpi()

◆ device_free() [1/2]

◆ device_free() [2/2]

◆ eye()

◆ frank_matrix()

◆ frank_matrix_eigenvalue()

◆ get_default_device()

◆ get_num_devices()

◆ get_residual_l2() [1/54]

◆ get_residual_l2() [2/54]

◆ get_residual_l2() [3/54]

◆ get_residual_l2() [4/54]

◆ get_residual_l2() [5/54]

◆ get_residual_l2() [6/54]

◆ get_residual_l2() [7/54]

◆ get_residual_l2() [8/54]

◆ get_residual_l2() [9/54]

◆ get_residual_l2() [10/54]

◆ get_residual_l2() [11/54]

◆ get_residual_l2() [12/54]

◆ get_residual_l2() [13/54]

◆ get_residual_l2() [14/54]

◆ get_residual_l2() [15/54]

◆ get_residual_l2() [16/54]

◆ get_residual_l2() [17/54]

◆ get_residual_l2() [18/54]

◆ get_residual_l2() [19/54]

◆ get_residual_l2() [20/54]

◆ get_residual_l2() [21/54]

◆ get_residual_l2() [22/54]

◆ get_residual_l2() [23/54]

◆ get_residual_l2() [24/54]

◆ get_residual_l2() [25/54]

◆ get_residual_l2() [26/54]

◆ get_residual_l2() [27/54]

◆ get_residual_l2() [28/54]

◆ get_residual_l2() [29/54]

◆ get_residual_l2() [30/54]

◆ get_residual_l2() [31/54]

◆ get_residual_l2() [32/54]

◆ get_residual_l2() [33/54]

◆ get_residual_l2() [34/54]

◆ get_residual_l2() [35/54]

◆ get_residual_l2() [36/54]

◆ get_residual_l2() [37/54]

◆ get_residual_l2() [38/54]

◆ get_residual_l2() [39/54]

◆ get_residual_l2() [40/54]

◆ get_residual_l2() [41/54]

◆ get_residual_l2() [42/54]

◆ get_residual_l2() [43/54]

◆ get_residual_l2() [44/54]

◆ get_residual_l2() [45/54]

◆ get_residual_l2() [46/54]

◆ get_residual_l2() [47/54]

◆ get_residual_l2() [48/54]

◆ get_residual_l2() [49/54]

◆ get_residual_l2() [50/54]

◆ get_residual_l2() [51/54]

◆ get_residual_l2() [52/54]

◆ get_residual_l2() [53/54]

◆ get_residual_l2() [54/54]

◆ is_same_device_mem_stat() [1/2]

◆ is_same_device_mem_stat() [2/2]

◆ is_same_size() [1/6]

◆ is_same_size() [2/6]

◆ is_same_size() [3/6]

◆ is_same_size() [4/6]

◆ is_same_size() [5/6]