blas_sparse Module Reference

## Data Types

interface | uscr_insert_entry
| A Sparse BLAS interface for RSB. More...
interface | uscr_insert_entries
| inserts multiple entries More...
interface | uscr_insert_col
| inserts a sparse column More...
interface | uscr_insert_row
| inserts a sparse row More...
interface | uscr_insert_clique
| inserts a clique More...
interface | uscr_insert_block
| inserts a dense block More...
interface | usmv
| multiplication : c <- beta c + alpha A b More...
interface | ussv
| triangular solve: b <- alpha A^-1 b More...
interface | usmm
| multiplication : c <- beta c + alpha A b More...
interface | ussm
| triangular solve: b <- alpha A^-1 b More...
interface | rsb_blas_get_mtx

## Functions/Subroutines

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 , depending on the value of `transA`.
subroutine | dusmv (transa, alpha, a, x, incx, y, incy, istat)
| Multiply by a dense vector. Either of , depending on the value of `transA`.
subroutine | cusmv (transa, alpha, a, x, incx, y, incy, istat)
| Multiply by a dense vector. Either of , depending on the value of `transA`.
subroutine | zusmv (transa, alpha, a, x, incx, y, incy, istat)
| Multiply by a dense vector. Either of , depending on the value of `transA`.
subroutine | sussv (transt, alpha, t, x, incx, istat)
| Triangular solve, by a dense vector. Either of , depending on the value of `transT`.
subroutine | dussv (transt, alpha, t, x, incx, istat)
| Triangular solve, by a dense vector. Either of , depending on the value of `transT`.
subroutine | cussv (transt, alpha, t, x, incx, istat)
| Triangular solve, by a dense vector. Either of , depending on the value of `transT`.
subroutine | zussv (transt, alpha, t, x, incx, istat)
| Triangular solve, by a dense vector. Either of , 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 , 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 , 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 , 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 , 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 , 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 , 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 , 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 , depending on the value of `transT`.

## 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_rec =9993
integer, parameter | blas_rsb_rep_hwi =9994
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
integer, parameter | rsb_blas_idx_kind =4
integer, parameter | rsb_blas_ist_kind =4

## Function/Subroutine Documentation

## cuscr_begin()

subroutine blas_sparse::cuscr_begin | ( | integer(kind=rsb_blas_idx_kind) | m,
|  | integer(kind=rsb_blas_idx_kind) | n,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | complex(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | k,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nrhs,
|  | complex(kind(1.e0)) | alpha,
|  | integer | a,
|  | complex(kind(1.e0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | complex(kind(1.e0)), dimension (:,:) | c,
|  | integer(kind=rsb_blas_idx_kind) | ldc,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense matrix (aka multi-vector). Either of , 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 .
  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.\nIf `--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(kind=rsb_blas_idx_kind) | incx,
|  | complex(kind(1.e0)), dimension (:) | y,
|  | integer(kind=rsb_blas_idx_kind) | incy,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense vector. Either of
, depending on the value of `transA`.

Parameters

  transA | Transposition operator for matrix A.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | nrhs,
|  | complex(kind(1.e0)) | alpha,
|  | integer | t,
|  | complex(kind(1.e0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense matrix (aka multi-vector). Either of , 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 .
  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(kind=rsb_blas_idx_kind) | incx,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense vector. Either of , depending on the value of `transT`.

Parameters

  transT | Transposition operator for matrix T.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | m,
|  | integer(kind=rsb_blas_idx_kind) | n,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | real(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | k,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nrhs,
|  | real(kind(1.d0)) | alpha,
|  | integer | a,
|  | real(kind(1.d0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | real(kind(1.d0)), dimension (:,:) | c,
|  | integer(kind=rsb_blas_idx_kind) | ldc,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense matrix (aka multi-vector). Either of , 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 .
  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.\nIf `--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(kind=rsb_blas_idx_kind) | incx,
|  | real(kind(1.d0)), dimension (:) | y,
|  | integer(kind=rsb_blas_idx_kind) | incy,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense vector. Either of
, depending on the value of `transA`.

Parameters

  transA | Transposition operator for matrix A.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | nrhs,
|  | real(kind(1.d0)) | alpha,
|  | integer | t,
|  | real(kind(1.d0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense matrix (aka multi-vector). Either of , 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 .
  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(kind=rsb_blas_idx_kind) | incx,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense vector. Either of , depending on the value of `transT`.

Parameters

  transT | Transposition operator for matrix T.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | m,
|  | integer(kind=rsb_blas_idx_kind) | n,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | real(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | real(kind(1.e0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | k,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nrhs,
|  | real(kind(1.e0)) | alpha,
|  | integer | a,
|  | real(kind(1.e0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | real(kind(1.e0)), dimension (:,:) | c,
|  | integer(kind=rsb_blas_idx_kind) | ldc,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense matrix (aka multi-vector). Either of , 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 .
  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.\nIf `--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(kind=rsb_blas_idx_kind) | incx,
|  | real(kind(1.e0)), dimension (:) | y,
|  | integer(kind=rsb_blas_idx_kind) | incy,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense vector. Either of
, depending on the value of `transA`.

Parameters

  transA | Transposition operator for matrix A.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | nrhs,
|  | real(kind(1.e0)) | alpha,
|  | integer | t,
|  | real(kind(1.e0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense matrix (aka multi-vector). Either of , 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 .
  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(kind=rsb_blas_idx_kind) | incx,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense vector. Either of , depending on the value of `transT`.

Parameters

  transT | Transposition operator for matrix T.
  alpha | Value for .
  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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind) | 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | m,
|  | integer(kind=rsb_blas_idx_kind) | n,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | k,
|  | integer(kind=rsb_blas_idx_kind) | l,
|  | complex(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind) | row_stride,
|  | integer(kind=rsb_blas_idx_kind) | col_stride,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | jndx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | j,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | i,
|  | integer(kind=rsb_blas_idx_kind) | nnz,
|  | complex(kind(1.d0)), dimension (:) | val,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | indx,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | mb,
|  | integer(kind=rsb_blas_idx_kind) | nb,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | k,
|  | integer(kind=rsb_blas_idx_kind), dimension (:) | l,
|  | integer, intent(out) | a,
|  | integer(kind=rsb_blas_ist_kind), 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(kind=rsb_blas_idx_kind) | nrhs,
|  | complex(kind(1.d0)) | alpha,
|  | integer | a,
|  | complex(kind(1.d0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | complex(kind(1.d0)), dimension (:,:) | c,
|  | integer(kind=rsb_blas_idx_kind) | ldc,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense matrix (aka multi-vector). Either of , 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 .
  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.\nIf `--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(kind=rsb_blas_idx_kind) | incx,
|  | complex(kind(1.d0)), dimension (:) | y,
|  | integer(kind=rsb_blas_idx_kind) | incy,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Multiply by a dense vector. Either of
, depending on the value of `transA`.

Parameters

  transA | Transposition operator for matrix A.
  alpha | Value for .
  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(kind=rsb_blas_idx_kind) | nrhs,
|  | complex(kind(1.d0)) | alpha,
|  | integer | t,
|  | complex(kind(1.d0)), dimension (:,:) | b,
|  | integer(kind=rsb_blas_idx_kind) | ldb,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense matrix (aka multi-vector). Either of , 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 .
  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(kind=rsb_blas_idx_kind) | incx,
|  | integer(kind=rsb_blas_ist_kind), intent(out) | istat )

Triangular solve, by a dense vector. Either of , depending on the value of `transT`.

Parameters

  transT | Transposition operator for matrix T.
  alpha | Value for .
  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_hwi

integer, parameter blas_sparse::blas_rsb_rep_hwi =9994

## blas_rsb_rep_rec

integer, parameter blas_sparse::blas_rsb_rep_rec =9993

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

## rsb_blas_idx_kind

integer, parameter blas_sparse::rsb_blas_idx_kind =4

## rsb_blas_ist_kind

integer, parameter blas_sparse::rsb_blas_ist_kind =4