Data Types
interface	rsb_blas_get_mtx

interface	uscr_insert_block
	inserts a dense block More...

interface	uscr_insert_clique
	inserts a clique More...

interface	uscr_insert_col
	inserts a sparse column More...

interface	uscr_insert_entries
	inserts multiple entries More...

interface	uscr_insert_entry
	A Sparse BLAS interface for RSB. More...

interface	uscr_insert_row
	inserts a sparse row More...

interface	usmm
	multiplication : c <- beta c + alpha A b More...

interface	usmv
	multiplication : c <- beta c + alpha A b More...

interface	ussm
	triangular solve: b <- alpha A^-1 b More...

interface	ussv
	triangular solve: b <- alpha A^-1 b More...

Functions/Subroutines
subroutine	usds (A, istat)
	Destroys a matrix. More...

subroutine	uscr_end (A, istat)
	Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines. More...

subroutine	usgp (A, pname, istat)
	Get a matrix property. More...

subroutine	ussp (A, pname, istat)
	Set a matrix property. Should be called just after creation, before nonzeroes insertion. More...

subroutine	suscr_begin (m, n, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	duscr_begin (m, n, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	cuscr_begin (m, n, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	zuscr_begin (m, n, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	suscr_block_begin (Mb, Nb, k, l, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	duscr_block_begin (Mb, Nb, k, l, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	cuscr_block_begin (Mb, Nb, k, l, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	zuscr_block_begin (Mb, Nb, k, l, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	suscr_variable_block_begin (Mb, Nb, K, L, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	duscr_variable_block_begin (Mb, Nb, K, L, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	cuscr_variable_block_begin (Mb, Nb, K, L, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	zuscr_variable_block_begin (Mb, Nb, K, L, A, istat)
	Allocates an empty matrix (A) and leaves it in build state. More...

subroutine	suscr_end (A, istat)
	Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines. More...

subroutine	duscr_end (A, istat)
	Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines. More...

subroutine	cuscr_end (A, istat)
	Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines. More...

subroutine	zuscr_end (A, istat)
	Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines. More...

subroutine	suscr_insert_entry (A, val, i, j, istat)
	Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_entry (A, val, i, j, istat)
	Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_entry (A, val, i, j, istat)
	Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_entry (A, val, i, j, istat)
	Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	suscr_insert_entries (A, nnz, val, indx, jndx, istat)
	Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_entries (A, nnz, val, indx, jndx, istat)
	Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_entries (A, nnz, val, indx, jndx, istat)
	Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_entries (A, nnz, val, indx, jndx, istat)
	Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	suscr_insert_col (A, j, nnz, val, indx, istat)
	Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_col (A, j, nnz, val, indx, istat)
	Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_col (A, j, nnz, val, indx, istat)
	Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_col (A, j, nnz, val, indx, istat)
	Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	suscr_insert_row (A, i, nnz, val, indx, istat)
	Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_row (A, i, nnz, val, indx, istat)
	Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_row (A, i, nnz, val, indx, istat)
	Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_row (A, i, nnz, val, indx, istat)
	Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together. More...

subroutine	suscr_insert_clique (A, k, l, val, row_stride, col_stride, indx, jndx, istat)
	Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_clique (A, k, l, val, row_stride, col_stride, indx, jndx, istat)
	Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_clique (A, k, l, val, row_stride, col_stride, indx, jndx, istat)
	Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_clique (A, k, l, val, row_stride, col_stride, indx, jndx, istat)
	Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together. More...

subroutine	suscr_insert_block (A, val, row_stride, col_stride, i, j, istat)
	Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked `begin` function. If not called a blocked `begin` function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together. More...

subroutine	duscr_insert_block (A, val, row_stride, col_stride, i, j, istat)
	Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked `begin` function. If not called a blocked `begin` function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together. More...

subroutine	cuscr_insert_block (A, val, row_stride, col_stride, i, j, istat)
	Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked `begin` function. If not called a blocked `begin` function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together. More...

subroutine	zuscr_insert_block (A, val, row_stride, col_stride, i, j, istat)
	Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked `begin` function. If not called a blocked `begin` function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together. More...

subroutine	susmv (transA, alpha, A, x, incx, y, incy, istat)
	Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of `transA`. More...

subroutine	dusmv (transA, alpha, A, x, incx, y, incy, istat)
	Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of `transA`. More...

subroutine	cusmv (transA, alpha, A, x, incx, y, incy, istat)
	Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of `transA`. More...

subroutine	zusmv (transA, alpha, A, x, incx, y, incy, istat)
	Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of `transA`. More...

subroutine	sussv (transT, alpha, T, x, incx, istat)
	Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of `transT`. More...

subroutine	dussv (transT, alpha, T, x, incx, istat)
	Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of `transT`. More...

subroutine	cussv (transT, alpha, T, x, incx, istat)
	Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of `transT`. More...

subroutine	zussv (transT, alpha, T, x, incx, istat)
	Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of `transT`. More...

subroutine	susmm (order, transA, nrhs, alpha, A, b, ldb, c, ldc, istat)
	Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of `transA`. More...

subroutine	dusmm (order, transA, nrhs, alpha, A, b, ldb, c, ldc, istat)
	Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of `transA`. More...

subroutine	cusmm (order, transA, nrhs, alpha, A, b, ldb, c, ldc, istat)
	Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of `transA`. More...

subroutine	zusmm (order, transA, nrhs, alpha, A, b, ldb, c, ldc, istat)
	Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of `transA`. More...

subroutine	sussm (order, transT, nrhs, alpha, T, b, ldb, istat)
	Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of `transT`. More...

subroutine	dussm (order, transT, nrhs, alpha, T, b, ldb, istat)
	Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of `transT`. More...

subroutine	cussm (order, transT, nrhs, alpha, T, b, ldb, istat)
	Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of `transT`. More...

subroutine	zussm (order, transT, nrhs, alpha, T, b, ldb, istat)
	Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of `transT`. More...

Variables
integer, parameter	blas_sparse_const_success =0

integer, parameter	blas_sparse_const_failure =-1

integer, parameter	blas_sparse_const_not_available =-9999

integer, parameter	blas_rowmajor =101

integer, parameter	blas_colmajor =102

integer, parameter	blas_no_trans =111

integer, parameter	blas_trans =112

integer, parameter	blas_conj_trans =113

integer, parameter	blas_upper =121

integer, parameter	blas_lower =122

integer, parameter	blas_non_unit_diag =131

integer, parameter	blas_unit_diag =132

integer, parameter	blas_left_side =141

integer, parameter	blas_right_side =142

integer, parameter	blas_base =151

integer, parameter	blas_t =152

integer, parameter	blas_rnd =153

integer, parameter	blas_ieee =154

integer, parameter	blas_emin =155

integer, parameter	blas_emax =156

integer, parameter	blas_eps =157

integer, parameter	blas_prec =158

integer, parameter	blas_underflow =159

integer, parameter	blas_overflow =160

integer, parameter	blas_sfmin =161

integer, parameter	blas_one_norm =171

integer, parameter	blas_real_one_norm =172

integer, parameter	blas_two_norm =173

integer, parameter	blas_frobenius_norm =174

integer, parameter	blas_inf_norm =175

integer, parameter	blas_real_inf_norm =176

integer, parameter	blas_max_norm =177

integer, parameter	blas_real_max_norm =178

integer, parameter	blas_increasing_order =181

integer, parameter	blas_decreasing_order =182

integer, parameter	blas_conj =191

integer, parameter	blas_no_conj =192

integer, parameter	blas_jrot_inner =201

integer, parameter	blas_jrot_outer =202

integer, parameter	blas_jrot_sorted =203

integer, parameter	blas_prec_single =211

integer, parameter	blas_prec_double =212

integer, parameter	blas_prec_indigenous =213

integer, parameter	blas_prec_extra =214

integer, parameter	blas_zero_base =221

integer, parameter	blas_one_base =222

integer, parameter	blas_general =231

integer, parameter	blas_symmetric =232

integer, parameter	blas_hermitian =233

integer, parameter	blas_triangular =234

integer, parameter	blas_lower_triangular =235

integer, parameter	blas_upper_triangular =236

integer, parameter	blas_lower_symmetric =237

integer, parameter	blas_upper_symmetric =238

integer, parameter	blas_lower_hermitian =239

integer, parameter	blas_upper_hermitian =240

integer, parameter	blas_complex =241

integer, parameter	blas_real =242

integer, parameter	blas_double_precision =243

integer, parameter	blas_single_precision =244

integer, parameter	blas_num_rows =251

integer, parameter	blas_num_cols =252

integer, parameter	blas_num_nonzeros =253

integer, parameter	blas_invalid_handle =261

integer, parameter	blas_new_handle =262

integer, parameter	blas_open_handle =263

integer, parameter	blas_valid_handle =264

integer, parameter	blas_regular =271

integer, parameter	blas_irregular =272

integer, parameter	blas_block =273

integer, parameter	blas_unassembled =274

integer, parameter	blas_rsb_spmv_autotuning_on =6660

integer, parameter	blas_rsb_spmv_autotuning_off =6661

integer, parameter	blas_rsb_spmv_n_autotuning_on =6662

integer, parameter	blas_rsb_spmv_n_autotuning_off =6663

integer, parameter	blas_rsb_spmv_t_autotuning_on =6664

integer, parameter	blas_rsb_spmv_t_autotuning_off =6665

integer, parameter	blas_rsb_autotune_next_operation =6666

integer, parameter	blas_rsb_rep_rsb =9995

integer, parameter	blas_rsb_rep_csr =9996

integer, parameter	blas_rsb_rep_coo =9997

integer, parameter	blas_rsb_duplicates_ovw =9998

integer, parameter	blas_rsb_duplicates_sum =9999

Function/Subroutine Documentation

◆ cuscr_begin()

subroutine blas_sparse::cuscr_begin	(	integer	m,
		integer	n,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

m	Is the count of rows.
n	Is the count of columns.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ cuscr_block_begin()

subroutine blas_sparse::cuscr_block_begin	(	integer	Mb,
		integer	Nb,
		integer	k,
		integer	l,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

k,l	Are row and column dimensions when specifying a matrix as BCSR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ cuscr_end()

subroutine blas_sparse::cuscr_end	(	integer	A,
		integer, intent(out)	istat
	)

Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_block()

subroutine blas_sparse::cuscr_insert_block	(	integer	A,
		complex(kind(1.e0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked begin function. If not called a blocked begin function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
row_stride,col_stride	Row and column strides in accessing `val`.
i,j	Block row/column indices.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

See also: BLAS_cuscr_block_begin, BLAS_cuscr_block_begin, BLAS_duscr_block_begin, BLAS_zuscr_block_begin, BLAS_cuscr_begin, BLAS_suscr_begin, BLAS_duscr_begin, BLAS_zuscr_begin.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_clique()

subroutine blas_sparse::cuscr_insert_clique	(	integer	A,
		integer	k,
		integer	l,
		complex(kind(1.e0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
k,l	Clique rows and columns count.
val	Array of values.
row_stride,col_stride	Row/columns stride in accessing the clique.
indx,jndx	Row/column indices arrays.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_col()

subroutine blas_sparse::cuscr_insert_col	(	integer	A,
		integer	j,
		integer	nnz,
		complex(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
j	Column index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_entries()

subroutine blas_sparse::cuscr_insert_entries	(	integer	A,
		integer	nnz,
		complex(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.
jndx	Column indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_entry()

subroutine blas_sparse::cuscr_insert_entry	(	integer	A,
		complex(kind(1.e0))	val,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
val	Array of values.
i,j	Row and column indices.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_insert_row()

subroutine blas_sparse::cuscr_insert_row	(	integer	A,
		integer	i,
		integer	nnz,
		complex(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
i	Row index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row index.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cuscr_variable_block_begin()

subroutine blas_sparse::cuscr_variable_block_begin	(	integer	Mb,
		integer	Nb,
		integer, dimension (:)	K,
		integer, dimension (:)	L,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

K,L	Are arrays specifying row/column block sizes when specifying a matrix as VBR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ cusmm()

subroutine blas_sparse::cusmm	(	integer	order,
		integer	transA,
		integer	nrhs,
		complex(kind(1.e0))	alpha,
		integer	A,
		complex(kind(1.e0)), dimension (:,:)	b,
		integer	ldb,
		complex(kind(1.e0)), dimension (:,:)	c,
		integer	ldc,
		integer, intent(out)	istat
	)

Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of transA.

Parameters

order	layour of the dense array.
transA	Transposition operator for matrix A.
nrhs	Number of right hand side columns.
A	A valid matrix handle.
alpha	Value for $\alpha$ .
b	Dense vector b.
ldb	Leading dimension of b.
c	Dense vector c.
ldc	Leading dimension of c.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cusmv()

subroutine blas_sparse::cusmv	(	integer	transA,
		complex(kind(1.e0))	alpha,
		integer	A,
		complex(kind(1.e0)), dimension (:)	x,
		integer	incx,
		complex(kind(1.e0)), dimension (:)	y,
		integer	incy,
		integer, intent(out)	istat
	)

Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of transA.

Parameters

transA	Transposition operator for matrix A.
alpha	Value for $\alpha$ .
A	A valid matrix handle.
x	Dense vector x.
incx	Stride of x.
y	Dense vector y.
incy	Stride of y.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cussm()

subroutine blas_sparse::cussm	(	integer	order,
		integer	transT,
		integer	nrhs,
		complex(kind(1.e0))	alpha,
		integer	T,
		complex(kind(1.e0)), dimension (:,:)	b,
		integer	ldb,
		integer, intent(out)	istat
	)

Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of transT.

Parameters

order	layour of the dense array.
transT	Transposition operator for matrix T.
nrhs	Number of right hand side columns.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
b	Dense vector b.
ldb	Leading dimension of b.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ cussv()

subroutine blas_sparse::cussv	(	integer	transT,
		complex(kind(1.e0))	alpha,
		integer	T,
		complex(kind(1.e0)), dimension (:)	x,
		integer	incx,
		integer, intent(out)	istat
	)

Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of transT.

Parameters

transT	Transposition operator for matrix T.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
x	Dense vector x.
incx	Stride of x.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_begin()

subroutine blas_sparse::duscr_begin	(	integer	m,
		integer	n,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

m	Is the count of rows.
n	Is the count of columns.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ duscr_block_begin()

subroutine blas_sparse::duscr_block_begin	(	integer	Mb,
		integer	Nb,
		integer	k,
		integer	l,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

k,l	Are row and column dimensions when specifying a matrix as BCSR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ duscr_end()

subroutine blas_sparse::duscr_end	(	integer	A,
		integer, intent(out)	istat
	)

Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_block()

subroutine blas_sparse::duscr_insert_block	(	integer	A,
		real(kind(1.d0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked begin function. If not called a blocked begin function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
row_stride,col_stride	Row and column strides in accessing `val`.
i,j	Block row/column indices.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

See also: BLAS_cuscr_block_begin, BLAS_cuscr_block_begin, BLAS_duscr_block_begin, BLAS_zuscr_block_begin, BLAS_cuscr_begin, BLAS_suscr_begin, BLAS_duscr_begin, BLAS_zuscr_begin.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_clique()

subroutine blas_sparse::duscr_insert_clique	(	integer	A,
		integer	k,
		integer	l,
		real(kind(1.d0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
k,l	Clique rows and columns count.
val	Array of values.
row_stride,col_stride	Row/columns stride in accessing the clique.
indx,jndx	Row/column indices arrays.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_col()

subroutine blas_sparse::duscr_insert_col	(	integer	A,
		integer	j,
		integer	nnz,
		real(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
j	Column index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_entries()

subroutine blas_sparse::duscr_insert_entries	(	integer	A,
		integer	nnz,
		real(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.
jndx	Column indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_entry()

subroutine blas_sparse::duscr_insert_entry	(	integer	A,
		real(kind(1.d0))	val,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
val	Array of values.
i,j	Row and column indices.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_insert_row()

subroutine blas_sparse::duscr_insert_row	(	integer	A,
		integer	i,
		integer	nnz,
		real(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
i	Row index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row index.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ duscr_variable_block_begin()

subroutine blas_sparse::duscr_variable_block_begin	(	integer	Mb,
		integer	Nb,
		integer, dimension (:)	K,
		integer, dimension (:)	L,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

K,L	Are arrays specifying row/column block sizes when specifying a matrix as VBR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ dusmm()

subroutine blas_sparse::dusmm	(	integer	order,
		integer	transA,
		integer	nrhs,
		real(kind(1.d0))	alpha,
		integer	A,
		real(kind(1.d0)), dimension (:,:)	b,
		integer	ldb,
		real(kind(1.d0)), dimension (:,:)	c,
		integer	ldc,
		integer, intent(out)	istat
	)

Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of transA.

Parameters

order	layour of the dense array.
transA	Transposition operator for matrix A.
nrhs	Number of right hand side columns.
A	A valid matrix handle.
alpha	Value for $\alpha$ .
b	Dense vector b.
ldb	Leading dimension of b.
c	Dense vector c.
ldc	Leading dimension of c.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ dusmv()

subroutine blas_sparse::dusmv	(	integer	transA,
		real(kind(1.d0))	alpha,
		integer	A,
		real(kind(1.d0)), dimension (:)	x,
		integer	incx,
		real(kind(1.d0)), dimension (:)	y,
		integer	incy,
		integer, intent(out)	istat
	)

Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of transA.

Parameters

transA	Transposition operator for matrix A.
alpha	Value for $\alpha$ .
A	A valid matrix handle.
x	Dense vector x.
incx	Stride of x.
y	Dense vector y.
incy	Stride of y.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ dussm()

subroutine blas_sparse::dussm	(	integer	order,
		integer	transT,
		integer	nrhs,
		real(kind(1.d0))	alpha,
		integer	T,
		real(kind(1.d0)), dimension (:,:)	b,
		integer	ldb,
		integer, intent(out)	istat
	)

Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of transT.

Parameters

order	layour of the dense array.
transT	Transposition operator for matrix T.
nrhs	Number of right hand side columns.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
b	Dense vector b.
ldb	Leading dimension of b.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ dussv()

subroutine blas_sparse::dussv	(	integer	transT,
		real(kind(1.d0))	alpha,
		integer	T,
		real(kind(1.d0)), dimension (:)	x,
		integer	incx,
		integer, intent(out)	istat
	)

Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of transT.

Parameters

transT	Transposition operator for matrix T.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
x	Dense vector x.
incx	Stride of x.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_begin()

subroutine blas_sparse::suscr_begin	(	integer	m,
		integer	n,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

m	Is the count of rows.
n	Is the count of columns.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ suscr_block_begin()

subroutine blas_sparse::suscr_block_begin	(	integer	Mb,
		integer	Nb,
		integer	k,
		integer	l,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

k,l	Are row and column dimensions when specifying a matrix as BCSR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ suscr_end()

subroutine blas_sparse::suscr_end	(	integer	A,
		integer, intent(out)	istat
	)

Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_block()

subroutine blas_sparse::suscr_insert_block	(	integer	A,
		real(kind(1.e0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked begin function. If not called a blocked begin function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
row_stride,col_stride	Row and column strides in accessing `val`.
i,j	Block row/column indices.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

See also: BLAS_cuscr_block_begin, BLAS_cuscr_block_begin, BLAS_duscr_block_begin, BLAS_zuscr_block_begin, BLAS_cuscr_begin, BLAS_suscr_begin, BLAS_duscr_begin, BLAS_zuscr_begin.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_clique()

subroutine blas_sparse::suscr_insert_clique	(	integer	A,
		integer	k,
		integer	l,
		real(kind(1.e0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
k,l	Clique rows and columns count.
val	Array of values.
row_stride,col_stride	Row/columns stride in accessing the clique.
indx,jndx	Row/column indices arrays.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_col()

subroutine blas_sparse::suscr_insert_col	(	integer	A,
		integer	j,
		integer	nnz,
		real(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
j	Column index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_entries()

subroutine blas_sparse::suscr_insert_entries	(	integer	A,
		integer	nnz,
		real(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.
jndx	Column indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_entry()

subroutine blas_sparse::suscr_insert_entry	(	integer	A,
		real(kind(1.e0))	val,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
val	Array of values.
i,j	Row and column indices.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_insert_row()

subroutine blas_sparse::suscr_insert_row	(	integer	A,
		integer	i,
		integer	nnz,
		real(kind(1.e0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
i	Row index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row index.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ suscr_variable_block_begin()

subroutine blas_sparse::suscr_variable_block_begin	(	integer	Mb,
		integer	Nb,
		integer, dimension (:)	K,
		integer, dimension (:)	L,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

K,L	Are arrays specifying row/column block sizes when specifying a matrix as VBR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ susmm()

subroutine blas_sparse::susmm	(	integer	order,
		integer	transA,
		integer	nrhs,
		real(kind(1.e0))	alpha,
		integer	A,
		real(kind(1.e0)), dimension (:,:)	b,
		integer	ldb,
		real(kind(1.e0)), dimension (:,:)	c,
		integer	ldc,
		integer, intent(out)	istat
	)

Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of transA.

Parameters

order	layour of the dense array.
transA	Transposition operator for matrix A.
nrhs	Number of right hand side columns.
A	A valid matrix handle.
alpha	Value for $\alpha$ .
b	Dense vector b.
ldb	Leading dimension of b.
c	Dense vector c.
ldc	Leading dimension of c.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ susmv()

subroutine blas_sparse::susmv	(	integer	transA,
		real(kind(1.e0))	alpha,
		integer	A,
		real(kind(1.e0)), dimension (:)	x,
		integer	incx,
		real(kind(1.e0)), dimension (:)	y,
		integer	incy,
		integer, intent(out)	istat
	)

Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of transA.

Parameters

transA	Transposition operator for matrix A.
alpha	Value for $\alpha$ .
A	A valid matrix handle.
x	Dense vector x.
incx	Stride of x.
y	Dense vector y.
incy	Stride of y.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ sussm()

subroutine blas_sparse::sussm	(	integer	order,
		integer	transT,
		integer	nrhs,
		real(kind(1.e0))	alpha,
		integer	T,
		real(kind(1.e0)), dimension (:,:)	b,
		integer	ldb,
		integer, intent(out)	istat
	)

Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of transT.

Parameters

order	layour of the dense array.
transT	Transposition operator for matrix T.
nrhs	Number of right hand side columns.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
b	Dense vector b.
ldb	Leading dimension of b.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ sussv()

subroutine blas_sparse::sussv	(	integer	transT,
		real(kind(1.e0))	alpha,
		integer	T,
		real(kind(1.e0)), dimension (:)	x,
		integer	incx,
		integer, intent(out)	istat
	)

Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of transT.

Parameters

transT	Transposition operator for matrix T.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
x	Dense vector x.
incx	Stride of x.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ uscr_end()

subroutine blas_sparse::uscr_end	(	integer, intent(in)	A,
		integer, intent(out)	istat
	)

Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ usds()

subroutine blas_sparse::usds	(	integer, intent(in)	A,
		integer	istat
	)

Destroys a matrix.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ usgp()

subroutine blas_sparse::usgp	(	integer, intent(in)	A,
		integer, intent(in)	pname,
		integer, intent(out)	istat
	)

Get a matrix property.

Parameters

A	A is the matrix to apply the property.
pname	The desired matrix property. For valid matrix properties, see blas_rsb_ext_type, blas_uplo_type, blas_diag_type, blas_conj_type, blas_base_type, blas_symmetry_type, blas_field_type, blas_size_type, blas_sparsity_optimization_type.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ ussp()

subroutine blas_sparse::ussp	(	integer, intent(in)	A,
		integer, intent(in)	pname,
		integer, intent(out)	istat
	)

Set a matrix property. Should be called just after creation, before nonzeroes insertion.

Parameters

A	A is the matrix to apply the property.
pname	The desired matrix property. For valid matrix properties, see blas_rsb_ext_type, blas_uplo_type, blas_diag_type, blas_conj_type, blas_base_type, blas_symmetry_type, blas_field_type, blas_size_type, blas_sparsity_optimization_type.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_begin()

subroutine blas_sparse::zuscr_begin	(	integer	m,
		integer	n,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

m	Is the count of rows.
n	Is the count of columns.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ zuscr_block_begin()

subroutine blas_sparse::zuscr_block_begin	(	integer	Mb,
		integer	Nb,
		integer	k,
		integer	l,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

k,l	Are row and column dimensions when specifying a matrix as BCSR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ zuscr_end()

subroutine blas_sparse::zuscr_end	(	integer	A,
		integer, intent(out)	istat
	)

Makes an assembled matrix out of a matrix in build state. After this, it is not possible anymore to insert nonzeroes, but computational routines.

Parameters

A	A valid matrix handle.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_block()

subroutine blas_sparse::zuscr_insert_block	(	integer	A,
		complex(kind(1.d0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts a whole block in a matrix, assuming it is in build state. The block size is assumed to be the one specified when calling the (type) corresponding matrix blocked begin function. If not called a blocked begin function, will assume 1x1 (that is, no) blocking. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
row_stride,col_stride	Row and column strides in accessing `val`.
i,j	Block row/column indices.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

See also: BLAS_cuscr_block_begin, BLAS_cuscr_block_begin, BLAS_duscr_block_begin, BLAS_zuscr_block_begin, BLAS_cuscr_begin, BLAS_suscr_begin, BLAS_duscr_begin, BLAS_zuscr_begin.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_clique()

subroutine blas_sparse::zuscr_insert_clique	(	integer	A,
		integer	k,
		integer	l,
		complex(kind(1.d0)), dimension (:)	val,
		integer	row_stride,
		integer	col_stride,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
k,l	Clique rows and columns count.
val	Array of values.
row_stride,col_stride	Row/columns stride in accessing the clique.
indx,jndx	Row/column indices arrays.

Warning: Signature of this routine for Fortran does not agree to the standard. This shall be corrected in a future release.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_col()

subroutine blas_sparse::zuscr_insert_col	(	integer	A,
		integer	j,
		integer	nnz,
		complex(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
j	Column index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_entries()

subroutine blas_sparse::zuscr_insert_entries	(	integer	A,
		integer	nnz,
		complex(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, dimension (:)	jndx,
		integer, intent(out)	istat
	)

Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row indices array.
jndx	Column indices array.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_entry()

subroutine blas_sparse::zuscr_insert_entry	(	integer	A,
		complex(kind(1.d0))	val,
		integer	i,
		integer	j,
		integer, intent(out)	istat
	)

Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
val	Array of values.
val	Array of values.
i,j	Row and column indices.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_insert_row()

subroutine blas_sparse::zuscr_insert_row	(	integer	A,
		integer	i,
		integer	nnz,
		complex(kind(1.d0)), dimension (:)	val,
		integer, dimension (:)	indx,
		integer, intent(out)	istat
	)

Inserts a whole row in a matrix, assuming it is in build state. By default, duplicate entries will be summed together.

Parameters

A	A valid matrix handle.
i	Row index.
nnz	Number of nonzeroes to insert.
val	Array of values.
indx	Row index.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zuscr_variable_block_begin()

subroutine blas_sparse::zuscr_variable_block_begin	(	integer	Mb,
		integer	Nb,
		integer, dimension (:)	K,
		integer, dimension (:)	L,
		integer, intent(out)	A,
		integer, intent(out)	istat
	)

Allocates an empty matrix (A) and leaves it in build state.

Parameters

K,L	Are arrays specifying row/column block sizes when specifying a matrix as VBR.
Mb	Block rows count.
Nb	Block columns count.

Returns: A matrix handle in case of success, or -1 on error.

Parameters

istat	The return code will be written to `istat` (this is a Fortran routine): either 0 (success) or -1 (failure).
A	On success, a valid matrix handle will be written to A.

Todo:: Shall make A intent(inout) as well.

◆ zusmm()

subroutine blas_sparse::zusmm	(	integer	order,
		integer	transA,
		integer	nrhs,
		complex(kind(1.d0))	alpha,
		integer	A,
		complex(kind(1.d0)), dimension (:,:)	b,
		integer	ldb,
		complex(kind(1.d0)), dimension (:,:)	c,
		integer	ldc,
		integer, intent(out)	istat
	)

Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha A^T B+C,$ $C \leftarrow \alpha A^H B+C$ , depending on the value of transA.

Parameters

order	layour of the dense array.
transA	Transposition operator for matrix A.
nrhs	Number of right hand side columns.
A	A valid matrix handle.
alpha	Value for $\alpha$ .
b	Dense vector b.
ldb	Leading dimension of b.
c	Dense vector c.
ldc	Leading dimension of c.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zusmv()

subroutine blas_sparse::zusmv	(	integer	transA,
		complex(kind(1.d0))	alpha,
		integer	A,
		complex(kind(1.d0)), dimension (:)	x,
		integer	incx,
		complex(kind(1.d0)), dimension (:)	y,
		integer	incy,
		integer, intent(out)	istat
	)

Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y \leftarrow \alpha A^H X + Y$ , depending on the value of transA.

Parameters

transA	Transposition operator for matrix A.
alpha	Value for $\alpha$ .
A	A valid matrix handle.
x	Dense vector x.
incx	Stride of x.
y	Dense vector y.
incy	Stride of y.

Note: By setting the blas_rsb_autotune_next_operation property via BLAS_ussp (at any time) the next multiplication routine call (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm, BLAS_susmm, BLAS_zusmm, BLAS_cusmm) will invoke autotuning before carrying out the effective operation. The tuning will take in account parameters like transposition, number of right hand sides, and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default number of executing threads for this matrix will be determined once, at matrix assembly time, and employed irrespective of the default threads count (different values for transposed and untransposed multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.

See also: On the topic of autotuning, see also rsb_tune_spmm. If –enable-rsb-num-threads has been specified at configure time, the RSB_NUM_THREADS environment variable will override the number of executing threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zussm()

subroutine blas_sparse::zussm	(	integer	order,
		integer	transT,
		integer	nrhs,
		complex(kind(1.d0))	alpha,
		integer	T,
		complex(kind(1.d0)), dimension (:,:)	b,
		integer	ldb,
		integer, intent(out)	istat
	)

Triangular solve, by a dense matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$ , depending on the value of transT.

Parameters

order	layour of the dense array.
transT	Transposition operator for matrix T.
nrhs	Number of right hand side columns.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
b	Dense vector b.
ldb	Leading dimension of b.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

◆ zussv()

subroutine blas_sparse::zussv	(	integer	transT,
		complex(kind(1.d0))	alpha,
		integer	T,
		complex(kind(1.d0)), dimension (:)	x,
		integer	incx,
		integer, intent(out)	istat
	)

Triangular solve, by a dense vector. Either of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$ , depending on the value of transT.

Parameters

transT	Transposition operator for matrix T.
alpha	Value for $\alpha$ .
T	A valid triangular matrix handle.
x	Dense vector x.
incx	Stride of x.

Returns: On success, 0 is returned; on error, -1.

Parameters

istat The return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

Variable Documentation

◆ blas_base

integer, parameter blas_sparse::blas_base =151

◆ blas_block

integer, parameter blas_sparse::blas_block =273

◆ blas_colmajor

integer, parameter blas_sparse::blas_colmajor =102

◆ blas_complex

integer, parameter blas_sparse::blas_complex =241

◆ blas_conj

integer, parameter blas_sparse::blas_conj =191

◆ blas_conj_trans

integer, parameter blas_sparse::blas_conj_trans =113

◆ blas_decreasing_order

integer, parameter blas_sparse::blas_decreasing_order =182

◆ blas_double_precision

integer, parameter blas_sparse::blas_double_precision =243

◆ blas_emax

integer, parameter blas_sparse::blas_emax =156

◆ blas_emin

integer, parameter blas_sparse::blas_emin =155

◆ blas_eps

integer, parameter blas_sparse::blas_eps =157

◆ blas_frobenius_norm

integer, parameter blas_sparse::blas_frobenius_norm =174

◆ blas_general

integer, parameter blas_sparse::blas_general =231

◆ blas_hermitian

integer, parameter blas_sparse::blas_hermitian =233

◆ blas_ieee

integer, parameter blas_sparse::blas_ieee =154

◆ blas_increasing_order

integer, parameter blas_sparse::blas_increasing_order =181

◆ blas_inf_norm

integer, parameter blas_sparse::blas_inf_norm =175

◆ blas_invalid_handle

integer, parameter blas_sparse::blas_invalid_handle =261

◆ blas_irregular

integer, parameter blas_sparse::blas_irregular =272

◆ blas_jrot_inner

integer, parameter blas_sparse::blas_jrot_inner =201

◆ blas_jrot_outer

integer, parameter blas_sparse::blas_jrot_outer =202

◆ blas_jrot_sorted

integer, parameter blas_sparse::blas_jrot_sorted =203

◆ blas_left_side

integer, parameter blas_sparse::blas_left_side =141

◆ blas_lower

integer, parameter blas_sparse::blas_lower =122

◆ blas_lower_hermitian

integer, parameter blas_sparse::blas_lower_hermitian =239

◆ blas_lower_symmetric

integer, parameter blas_sparse::blas_lower_symmetric =237

◆ blas_lower_triangular

integer, parameter blas_sparse::blas_lower_triangular =235

◆ blas_max_norm

integer, parameter blas_sparse::blas_max_norm =177

◆ blas_new_handle

integer, parameter blas_sparse::blas_new_handle =262

◆ blas_no_conj

integer, parameter blas_sparse::blas_no_conj =192

◆ blas_no_trans

integer, parameter blas_sparse::blas_no_trans =111

◆ blas_non_unit_diag

integer, parameter blas_sparse::blas_non_unit_diag =131

◆ blas_num_cols

integer, parameter blas_sparse::blas_num_cols =252

◆ blas_num_nonzeros

integer, parameter blas_sparse::blas_num_nonzeros =253

◆ blas_num_rows

integer, parameter blas_sparse::blas_num_rows =251

◆ blas_one_base

integer, parameter blas_sparse::blas_one_base =222

◆ blas_one_norm

integer, parameter blas_sparse::blas_one_norm =171

◆ blas_open_handle

integer, parameter blas_sparse::blas_open_handle =263

◆ blas_overflow

integer, parameter blas_sparse::blas_overflow =160

◆ blas_prec

integer, parameter blas_sparse::blas_prec =158

◆ blas_prec_double

integer, parameter blas_sparse::blas_prec_double =212

◆ blas_prec_extra

integer, parameter blas_sparse::blas_prec_extra =214

◆ blas_prec_indigenous

integer, parameter blas_sparse::blas_prec_indigenous =213

◆ blas_prec_single

integer, parameter blas_sparse::blas_prec_single =211

◆ blas_real

integer, parameter blas_sparse::blas_real =242

◆ blas_real_inf_norm

integer, parameter blas_sparse::blas_real_inf_norm =176

◆ blas_real_max_norm

integer, parameter blas_sparse::blas_real_max_norm =178

◆ blas_real_one_norm

integer, parameter blas_sparse::blas_real_one_norm =172

◆ blas_regular

integer, parameter blas_sparse::blas_regular =271

◆ blas_right_side

integer, parameter blas_sparse::blas_right_side =142

◆ blas_rnd

integer, parameter blas_sparse::blas_rnd =153

◆ blas_rowmajor

integer, parameter blas_sparse::blas_rowmajor =101

◆ blas_rsb_autotune_next_operation

integer, parameter blas_sparse::blas_rsb_autotune_next_operation =6666

◆ blas_rsb_duplicates_ovw

integer, parameter blas_sparse::blas_rsb_duplicates_ovw =9998

◆ blas_rsb_duplicates_sum

integer, parameter blas_sparse::blas_rsb_duplicates_sum =9999

◆ blas_rsb_rep_coo

integer, parameter blas_sparse::blas_rsb_rep_coo =9997

◆ blas_rsb_rep_csr

integer, parameter blas_sparse::blas_rsb_rep_csr =9996

◆ blas_rsb_rep_rsb

integer, parameter blas_sparse::blas_rsb_rep_rsb =9995

◆ blas_rsb_spmv_autotuning_off

integer, parameter blas_sparse::blas_rsb_spmv_autotuning_off =6661

◆ blas_rsb_spmv_autotuning_on

integer, parameter blas_sparse::blas_rsb_spmv_autotuning_on =6660

◆ blas_rsb_spmv_n_autotuning_off

integer, parameter blas_sparse::blas_rsb_spmv_n_autotuning_off =6663

◆ blas_rsb_spmv_n_autotuning_on

integer, parameter blas_sparse::blas_rsb_spmv_n_autotuning_on =6662

◆ blas_rsb_spmv_t_autotuning_off

integer, parameter blas_sparse::blas_rsb_spmv_t_autotuning_off =6665

◆ blas_rsb_spmv_t_autotuning_on

integer, parameter blas_sparse::blas_rsb_spmv_t_autotuning_on =6664

◆ blas_sfmin

integer, parameter blas_sparse::blas_sfmin =161

◆ blas_single_precision

integer, parameter blas_sparse::blas_single_precision =244

◆ blas_sparse_const_failure

integer, parameter blas_sparse::blas_sparse_const_failure =-1

◆ blas_sparse_const_not_available

integer, parameter blas_sparse::blas_sparse_const_not_available =-9999

◆ blas_sparse_const_success

integer, parameter blas_sparse::blas_sparse_const_success =0

◆ blas_symmetric

integer, parameter blas_sparse::blas_symmetric =232

◆ blas_t

integer, parameter blas_sparse::blas_t =152

◆ blas_trans

integer, parameter blas_sparse::blas_trans =112

◆ blas_triangular

integer, parameter blas_sparse::blas_triangular =234

◆ blas_two_norm

integer, parameter blas_sparse::blas_two_norm =173

◆ blas_unassembled

integer, parameter blas_sparse::blas_unassembled =274

◆ blas_underflow

integer, parameter blas_sparse::blas_underflow =159

◆ blas_unit_diag

integer, parameter blas_sparse::blas_unit_diag =132

◆ blas_upper

integer, parameter blas_sparse::blas_upper =121

◆ blas_upper_hermitian

integer, parameter blas_sparse::blas_upper_hermitian =240

◆ blas_upper_symmetric

integer, parameter blas_sparse::blas_upper_symmetric =238

◆ blas_upper_triangular

integer, parameter blas_sparse::blas_upper_triangular =236

◆ blas_valid_handle

integer, parameter blas_sparse::blas_valid_handle =264

◆ blas_zero_base

integer, parameter blas_sparse::blas_zero_base =221

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ cuscr_begin()

◆ cuscr_block_begin()

◆ cuscr_end()

◆ cuscr_insert_block()

◆ cuscr_insert_clique()

◆ cuscr_insert_col()

◆ cuscr_insert_entries()

◆ cuscr_insert_entry()

◆ cuscr_insert_row()

◆ cuscr_variable_block_begin()

◆ cusmm()

◆ cusmv()

◆ cussm()

◆ cussv()

◆ duscr_begin()

◆ duscr_block_begin()

◆ duscr_end()

◆ duscr_insert_block()

◆ duscr_insert_clique()

◆ duscr_insert_col()

◆ duscr_insert_entries()

◆ duscr_insert_entry()

◆ duscr_insert_row()

◆ duscr_variable_block_begin()

◆ dusmm()

◆ dusmv()

◆ dussm()

◆ dussv()

◆ suscr_begin()

◆ suscr_block_begin()

◆ suscr_end()

◆ suscr_insert_block()

◆ suscr_insert_clique()

◆ suscr_insert_col()

◆ suscr_insert_entries()

◆ suscr_insert_entry()

◆ suscr_insert_row()

◆ suscr_variable_block_begin()

◆ susmm()

◆ susmv()

◆ sussm()

◆ sussv()

◆ uscr_end()

◆ usds()

◆ usgp()

◆ ussp()

◆ zuscr_begin()

◆ zuscr_block_begin()

◆ zuscr_end()

◆ zuscr_insert_block()

◆ zuscr_insert_clique()

◆ zuscr_insert_col()

◆ zuscr_insert_entries()

◆ zuscr_insert_entry()

◆ zuscr_insert_row()

◆ zuscr_variable_block_begin()

◆ zusmm()

◆ zusmv()

◆ zussm()

◆ zussv()

Variable Documentation

◆ blas_base

◆ blas_block

◆ blas_colmajor

◆ blas_complex

◆ blas_conj

◆ blas_conj_trans

◆ blas_decreasing_order

◆ blas_double_precision

◆ blas_emax

◆ blas_emin

◆ blas_eps

◆ blas_frobenius_norm

◆ blas_general

◆ blas_hermitian

◆ blas_ieee