librsb  1.2.0-rc7
Data Structures | Public Member Functions | Data Fields
blas_sparse Module Reference

Data Structures

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

Public Member Functions

subroutine usds (A, istat)
 Destroys a matrix.
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.
subroutine usgp (A, pname, istat)
 Get a matrix property.
subroutine ussp (A, pname, istat)
 Set a matrix property. Should be called just after creation, before nonzeroes insertion.
subroutine suscr_begin (m, n, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine duscr_begin (m, n, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine cuscr_begin (m, n, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine zuscr_begin (m, n, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine suscr_block_begin (Mb, Nb, k, l, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine duscr_block_begin (Mb, Nb, k, l, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine cuscr_block_begin (Mb, Nb, k, l, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine zuscr_block_begin (Mb, Nb, k, l, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine suscr_variable_block_begin (Mb, Nb, K, L, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine duscr_variable_block_begin (Mb, Nb, K, L, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine cuscr_variable_block_begin (Mb, Nb, K, L, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
subroutine zuscr_variable_block_begin (Mb, Nb, K, L, A, istat)
 Allocates an empty matrix (A) and leaves it in build state.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.

Data Fields

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

Member Function Documentation

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
mIs the count of rows.
nIs the count of columns.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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,lAre row and column dimensions when specifying a matrix as BCSR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
row_stride,col_strideRow and column strides in accessing val.
i,jBlock 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
k,lClique rows and columns count.
valArray of values.
row_stride,col_strideRow/columns stride in accessing the clique.
indx,jndxRow/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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
jColumn index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
jndxColumn indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
valArray of values.
i,jRow and column indices.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
iRow index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow index.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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,LAre arrays specifying row/column block sizes when specifying a matrix as VBR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
orderlayour of the dense array.
transATransposition operator for matrix A.
nrhsNumber of right hand side columns.
AA valid matrix handle.
alphaValue for $ \alpha $.
bDense vector b.
ldbLeading dimension of b.
cDense vector c.
ldcLeading 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transATransposition operator for matrix A.
alphaValue for $ \alpha $.
AA valid matrix handle.
xDense vector x.
incxStride of x.
yDense vector y.
incyStride 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
orderlayour of the dense array.
transTTransposition operator for matrix T.
nrhsNumber of right hand side columns.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
bDense vector b.
ldbLeading dimension of b.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transTTransposition operator for matrix T.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
xDense vector x.
incxStride of x.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
mIs the count of rows.
nIs the count of columns.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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,lAre row and column dimensions when specifying a matrix as BCSR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
row_stride,col_strideRow and column strides in accessing val.
i,jBlock 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
k,lClique rows and columns count.
valArray of values.
row_stride,col_strideRow/columns stride in accessing the clique.
indx,jndxRow/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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
jColumn index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
jndxColumn indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
valArray of values.
i,jRow and column indices.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
iRow index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow index.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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,LAre arrays specifying row/column block sizes when specifying a matrix as VBR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
orderlayour of the dense array.
transATransposition operator for matrix A.
nrhsNumber of right hand side columns.
AA valid matrix handle.
alphaValue for $ \alpha $.
bDense vector b.
ldbLeading dimension of b.
cDense vector c.
ldcLeading 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transATransposition operator for matrix A.
alphaValue for $ \alpha $.
AA valid matrix handle.
xDense vector x.
incxStride of x.
yDense vector y.
incyStride 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
orderlayour of the dense array.
transTTransposition operator for matrix T.
nrhsNumber of right hand side columns.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
bDense vector b.
ldbLeading dimension of b.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transTTransposition operator for matrix T.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
xDense vector x.
incxStride of x.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
mIs the count of rows.
nIs the count of columns.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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,lAre row and column dimensions when specifying a matrix as BCSR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
row_stride,col_strideRow and column strides in accessing val.
i,jBlock 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
k,lClique rows and columns count.
valArray of values.
row_stride,col_strideRow/columns stride in accessing the clique.
indx,jndxRow/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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
jColumn index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
jndxColumn indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
valArray of values.
i,jRow and column indices.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
iRow index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow index.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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,LAre arrays specifying row/column block sizes when specifying a matrix as VBR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
orderlayour of the dense array.
transATransposition operator for matrix A.
nrhsNumber of right hand side columns.
AA valid matrix handle.
alphaValue for $ \alpha $.
bDense vector b.
ldbLeading dimension of b.
cDense vector c.
ldcLeading 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transATransposition operator for matrix A.
alphaValue for $ \alpha $.
AA valid matrix handle.
xDense vector x.
incxStride of x.
yDense vector y.
incyStride 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
orderlayour of the dense array.
transTTransposition operator for matrix T.
nrhsNumber of right hand side columns.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
bDense vector b.
ldbLeading dimension of b.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transTTransposition operator for matrix T.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
xDense vector x.
incxStride of x.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
subroutine blas_sparse::usds ( integer, intent(in)  A,
integer  istat 
)

Destroys a matrix.

Parameters
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
subroutine blas_sparse::usgp ( integer, intent(in)  A,
integer, intent(in)  pname,
integer, intent(out)  istat 
)

Get a matrix property.

Parameters
AA is the matrix to apply the property.
pnameThe 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA is the matrix to apply the property.
pnameThe 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
mIs the count of rows.
nIs the count of columns.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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,lAre row and column dimensions when specifying a matrix as BCSR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
AA valid matrix handle.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
row_stride,col_strideRow and column strides in accessing val.
i,jBlock 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
k,lClique rows and columns count.
valArray of values.
row_stride,col_strideRow/columns stride in accessing the clique.
indx,jndxRow/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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
jColumn index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow indices array.
jndxColumn indices array.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
valArray of values.
valArray of values.
i,jRow and column indices.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
AA valid matrix handle.
iRow index.
nnzNumber of nonzeroes to insert.
valArray of values.
indxRow index.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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,LAre arrays specifying row/column block sizes when specifying a matrix as VBR.
MbBlock rows count.
NbBlock columns count.
Returns
A matrix handle in case of success, or -1 on error.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
AOn success, a valid matrix handle will be written to A.
Todo:
Shall make A intent(inout) as well.
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
orderlayour of the dense array.
transATransposition operator for matrix A.
nrhsNumber of right hand side columns.
AA valid matrix handle.
alphaValue for $ \alpha $.
bDense vector b.
ldbLeading dimension of b.
cDense vector c.
ldcLeading 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transATransposition operator for matrix A.
alphaValue for $ \alpha $.
AA valid matrix handle.
xDense vector x.
incxStride of x.
yDense vector y.
incyStride 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 untrasposed 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
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
orderlayour of the dense array.
transTTransposition operator for matrix T.
nrhsNumber of right hand side columns.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
bDense vector b.
ldbLeading dimension of b.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).
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
transTTransposition operator for matrix T.
alphaValue for $ \alpha $.
TA valid triangular matrix handle.
xDense vector x.
incxStride of x.
Returns
On success, 0 is returned; on error, -1.
Parameters
istatThe return code will be written to istat (this is a Fortran routine): either 0 (success) or -1 (failure).

Field Documentation

integer, parameter blas_sparse::blas_base = 151
integer, parameter blas_sparse::blas_block = 273
integer, parameter blas_sparse::blas_colmajor = 102
integer, parameter blas_sparse::blas_complex = 241
integer, parameter blas_sparse::blas_conj = 191
integer, parameter blas_sparse::blas_conj_trans = 113
integer, parameter blas_sparse::blas_decreasing_order = 182
integer, parameter blas_sparse::blas_double_precision = 243
integer, parameter blas_sparse::blas_emax = 156
integer, parameter blas_sparse::blas_emin = 155
integer, parameter blas_sparse::blas_eps = 157
integer, parameter blas_sparse::blas_frobenius_norm = 174
integer, parameter blas_sparse::blas_general = 231
integer, parameter blas_sparse::blas_hermitian = 233
integer, parameter blas_sparse::blas_ieee = 154
integer, parameter blas_sparse::blas_increasing_order = 181
integer, parameter blas_sparse::blas_inf_norm = 175
integer, parameter blas_sparse::blas_invalid_handle = 261
integer, parameter blas_sparse::blas_irregular = 272
integer, parameter blas_sparse::blas_jrot_inner = 201
integer, parameter blas_sparse::blas_jrot_outer = 202
integer, parameter blas_sparse::blas_jrot_sorted = 203
integer, parameter blas_sparse::blas_left_side = 141
integer, parameter blas_sparse::blas_lower = 122
integer, parameter blas_sparse::blas_lower_hermitian = 239
integer, parameter blas_sparse::blas_lower_symmetric = 237
integer, parameter blas_sparse::blas_lower_triangular = 235
integer, parameter blas_sparse::blas_max_norm = 177
integer, parameter blas_sparse::blas_new_handle = 262
integer, parameter blas_sparse::blas_no_conj = 192
integer, parameter blas_sparse::blas_no_trans = 111
integer, parameter blas_sparse::blas_non_unit_diag = 131
integer, parameter blas_sparse::blas_num_cols = 252
integer, parameter blas_sparse::blas_num_nonzeros = 253
integer, parameter blas_sparse::blas_num_rows = 251
integer, parameter blas_sparse::blas_one_base = 222
integer, parameter blas_sparse::blas_one_norm = 171
integer, parameter blas_sparse::blas_open_handle = 263
integer, parameter blas_sparse::blas_overflow = 160
integer, parameter blas_sparse::blas_prec = 158
integer, parameter blas_sparse::blas_prec_double = 212
integer, parameter blas_sparse::blas_prec_extra = 214
integer, parameter blas_sparse::blas_prec_indigenous = 213
integer, parameter blas_sparse::blas_prec_single = 211
integer, parameter blas_sparse::blas_real = 242
integer, parameter blas_sparse::blas_real_inf_norm = 176
integer, parameter blas_sparse::blas_real_max_norm = 178
integer, parameter blas_sparse::blas_real_one_norm = 172
integer, parameter blas_sparse::blas_regular = 271
integer, parameter blas_sparse::blas_right_side = 142
integer, parameter blas_sparse::blas_rnd = 153
integer, parameter blas_sparse::blas_rowmajor = 101
integer, parameter blas_sparse::blas_rsb_autotune_next_operation = 6666
integer, parameter blas_sparse::blas_rsb_duplicates_ovw = 9998
integer, parameter blas_sparse::blas_rsb_duplicates_sum = 9999
integer, parameter blas_sparse::blas_rsb_rep_coo = 9997
integer, parameter blas_sparse::blas_rsb_rep_csr = 9996
integer, parameter blas_sparse::blas_rsb_rep_rsb = 9995
integer, parameter blas_sparse::blas_rsb_spmv_autotuning_off = 6661
integer, parameter blas_sparse::blas_rsb_spmv_autotuning_on = 6660
integer, parameter blas_sparse::blas_rsb_spmv_n_autotuning_off = 6663
integer, parameter blas_sparse::blas_rsb_spmv_n_autotuning_on = 6662
integer, parameter blas_sparse::blas_rsb_spmv_t_autotuning_off = 6665
integer, parameter blas_sparse::blas_rsb_spmv_t_autotuning_on = 6664
integer, parameter blas_sparse::blas_sfmin = 161
integer, parameter blas_sparse::blas_single_precision = 244
integer, parameter blas_sparse::blas_sparse_const_failure = -1
integer, parameter blas_sparse::blas_sparse_const_not_available = -9999
integer, parameter blas_sparse::blas_sparse_const_success = 0
integer, parameter blas_sparse::blas_symmetric = 232
integer, parameter blas_sparse::blas_t = 152
integer, parameter blas_sparse::blas_trans = 112
integer, parameter blas_sparse::blas_triangular = 234
integer, parameter blas_sparse::blas_two_norm = 173
integer, parameter blas_sparse::blas_unassembled = 274
integer, parameter blas_sparse::blas_underflow = 159
integer, parameter blas_sparse::blas_unit_diag = 132
integer, parameter blas_sparse::blas_upper = 121
integer, parameter blas_sparse::blas_upper_hermitian = 240
integer, parameter blas_sparse::blas_upper_symmetric = 238
integer, parameter blas_sparse::blas_upper_triangular = 236
integer, parameter blas_sparse::blas_valid_handle = 264
integer, parameter blas_sparse::blas_zero_base = 221

The documentation for this module was generated from the following file: