The Sparse BLAS interface to librsb (blas_sparse.h, rsb_blas_sparse.F90)

A Sparse BLAS interface (see http://www.netlib.org/blas/blast-forum/) to `librsb`. Level 1 (vector-vector operations) is supported in a basic way. Level 2 (sparse matrix-dense vector operations) is supported fully. Level 3 (sparse matrix-dense matrix operations) is supported as a wrapper around Level 2. More...

## Functions

int | BLAS_susdot (const enum blas_conj_type conj, const int nnz, const float *x, const int *indx, const float *y, const int incy, float *r, const enum blas_base_type index_base)
void | blas_susdot_ (const enum blas_conj_type *conj, const int *nnz, const float *x, const int *indx, const float *y, const int *incy, float *r, const enum blas_base_type *index_base, int *istat)
int | BLAS_dusdot (const enum blas_conj_type conj, const int nnz, const double *x, const int *indx, const double *y, const int incy, double *r, const enum blas_base_type index_base)
void | blas_dusdot_ (const enum blas_conj_type *conj, const int *nnz, const double *x, const int *indx, const double *y, const int *incy, double *r, const enum blas_base_type *index_base, int *istat)
int | BLAS_cusdot (const enum blas_conj_type conj, const int nnz, const void *x, const int *indx, const void *y, const int incy, void *r, const enum blas_base_type index_base)
void | blas_cusdot_ (const enum blas_conj_type *conj, const int *nnz, const void *x, const int *indx, const void *y, const int *incy, void *r, const enum blas_base_type *index_base, int *istat)
int | BLAS_zusdot (const enum blas_conj_type conj, const int nnz, const void *x, const int *indx, const void *y, const int incy, void *r, const enum blas_base_type index_base)
void | blas_zusdot_ (const enum blas_conj_type *conj, const int *nnz, const void *x, const int *indx, const void *y, const int *incy, void *r, const enum blas_base_type *index_base, int *istat)
int | BLAS_susaxpy (const int nnz, float alpha, const float *x, const int *indx, float *y, const int incy, const enum blas_base_type index_base)
void | blas_susaxpy_ (const int *nnz, float *alpha, const float *x, const int *indx, float *y, const int *incy, const enum blas_base_type *index_base, int *istat)
int | BLAS_dusaxpy (const int nnz, double alpha, const double *x, const int *indx, double *y, const int incy, const enum blas_base_type index_base)
void | blas_dusaxpy_ (const int *nnz, double *alpha, const double *x, const int *indx, double *y, const int *incy, const enum blas_base_type *index_base, int *istat)
int | BLAS_cusaxpy (const int nnz, const void *alpha, const void *x, const int *indx, void *y, const int incy, const enum blas_base_type index_base)
void | blas_cusaxpy_ (const int *nnz, const void *alpha, const void *x, const int *indx, void *y, const int *incy, const enum blas_base_type *index_base, int *istat)
int | BLAS_zusaxpy (const int nnz, const void *alpha, const void *x, const int *indx, void *y, const int incy, const enum blas_base_type index_base)
void | blas_zusaxpy_ (const int *nnz, const void *alpha, const void *x, const int *indx, void *y, const int *incy, const enum blas_base_type *index_base, int *istat)
int | BLAS_susga (const int nnz, const float *y, const int incy, float *x, const int *indx, const enum blas_base_type index_base)
void | blas_susga_ (const int *nnz, const float *y, const int *incy, float *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_dusga (const int nnz, const double *y, const int incy, double *x, const int *indx, const enum blas_base_type index_base)
void | blas_dusga_ (const int *nnz, const double *y, const int *incy, double *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_cusga (const int nnz, const void *y, const int incy, void *x, const int *indx, const enum blas_base_type index_base)
void | blas_cusga_ (const int *nnz, const void *y, const int *incy, void *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_zusga (const int nnz, const void *y, const int incy, void *x, const int *indx, const enum blas_base_type index_base)
void | blas_zusga_ (const int *nnz, const void *y, const int *incy, void *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_susgz (const int nnz, float *y, const int incy, float *x, const int *indx, const enum blas_base_type index_base)
void | blas_susgz_ (const int *nnz, float *y, const int *incy, float *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_dusgz (const int nnz, double *y, const int incy, double *x, const int *indx, const enum blas_base_type index_base)
void | blas_dusgz_ (const int *nnz, double *y, const int *incy, double *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_cusgz (const int nnz, void *y, const int incy, void *x, const int *indx, const enum blas_base_type index_base)
void | blas_cusgz_ (const int *nnz, void *y, const int *incy, void *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_zusgz (const int nnz, void *y, const int incy, void *x, const int *indx, const enum blas_base_type index_base)
void | blas_zusgz_ (const int *nnz, void *y, const int *incy, void *x, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_sussc (const int nnz, const float *x, float *y, const int incy, const int *indx, const enum blas_base_type index_base)
void | blas_sussc_ (const int *nnz, const float *x, float *y, const int *incy, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_dussc (const int nnz, const double *x, double *y, const int incy, const int *indx, const enum blas_base_type index_base)
void | blas_dussc_ (const int *nnz, const double *x, double *y, const int *incy, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_cussc (const int nnz, const void *x, void *y, const int incy, const int *indx, const enum blas_base_type index_base)
void | blas_cussc_ (const int *nnz, const void *x, void *y, const int *incy, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_zussc (const int nnz, const void *x, void *y, const int incy, const int *indx, const enum blas_base_type index_base)
void | blas_zussc_ (const int *nnz, const void *x, void *y, const int *incy, const int *indx, const enum blas_base_type *index_base, int *istat)
int | BLAS_susmv (const enum blas_trans_type transA, float alpha, const blas_sparse_matrix A, const float *x, const int incx, float *y, const int incy)
void | blas_susmv_ (const enum blas_trans_type *transA, float *alpha, const blas_sparse_matrix *A, const float *x, const int *incx, float *y, const int *incy, int *istat)
int | BLAS_dusmv (const enum blas_trans_type transA, double alpha, const blas_sparse_matrix A, const double *x, const int incx, double *y, const int incy)
void | blas_dusmv_ (const enum blas_trans_type *transA, double *alpha, const blas_sparse_matrix *A, const double *x, const int *incx, double *y, const int *incy, int *istat)
int | BLAS_cusmv (const enum blas_trans_type transA, const void *alpha, const blas_sparse_matrix A, const void *x, const int incx, void *y, const int incy)
void | blas_cusmv_ (const enum blas_trans_type *transA, const void *alpha, const blas_sparse_matrix *A, const void *x, const int *incx, void *y, const int *incy, int *istat)
int | BLAS_zusmv (const enum blas_trans_type transA, const void *alpha, const blas_sparse_matrix A, const void *x, const int incx, void *y, const int incy)
void | blas_zusmv_ (const enum blas_trans_type *transA, const void *alpha, const blas_sparse_matrix *A, const void *x, const int *incx, void *y, const int *incy, int *istat)
int | BLAS_sussv (enum blas_trans_type transT, float alpha, const blas_sparse_matrix T, float *x, const int incx)
void | blas_sussv_ (enum blas_trans_type *transT, float *alpha, const blas_sparse_matrix *T, float *x, const int *incx, int *istat)
int | BLAS_dussv (enum blas_trans_type transT, double alpha, const blas_sparse_matrix T, double *x, const int incx)
void | blas_dussv_ (enum blas_trans_type *transT, double *alpha, const blas_sparse_matrix *T, double *x, const int *incx, int *istat)
int | BLAS_cussv (enum blas_trans_type transT, const void *alpha, const blas_sparse_matrix T, void *x, const int incx)
void | blas_cussv_ (enum blas_trans_type *transT, const void *alpha, const blas_sparse_matrix *T, void *x, const int *incx, int *istat)
int | BLAS_zussv (enum blas_trans_type transT, const void *alpha, const blas_sparse_matrix T, void *x, const int incx)
void | blas_zussv_ (enum blas_trans_type *transT, const void *alpha, const blas_sparse_matrix *T, void *x, const int *incx, int *istat)
int | BLAS_susmm (const enum blas_order_type order, const enum blas_trans_type transA, const int nrhs, float alpha, const blas_sparse_matrix A, const float *b, const int ldb, float *c, const int ldc)
void | blas_susmm_ (const enum blas_order_type *order, const enum blas_trans_type *transA, const int *nrhs, float *alpha, const blas_sparse_matrix *A, const float *b, const int *ldb, float *c, const int *ldc, int *istat)
int | BLAS_dusmm (const enum blas_order_type order, const enum blas_trans_type transA, const int nrhs, double alpha, const blas_sparse_matrix A, const double *b, const int ldb, double *c, const int ldc)
void | blas_dusmm_ (const enum blas_order_type *order, const enum blas_trans_type *transA, const int *nrhs, double *alpha, const blas_sparse_matrix *A, const double *b, const int *ldb, double *c, const int *ldc, int *istat)
int | BLAS_cusmm (const enum blas_order_type order, const enum blas_trans_type transA, const int nrhs, const void *alpha, const blas_sparse_matrix A, const void *b, const int ldb, void *c, const int ldc)
void | blas_cusmm_ (const enum blas_order_type *order, const enum blas_trans_type *transA, const int *nrhs, const void *alpha, const blas_sparse_matrix *A, const void *b, const int *ldb, void *c, const int *ldc, int *istat)
int | BLAS_zusmm (const enum blas_order_type order, const enum blas_trans_type transA, const int nrhs, const void *alpha, const blas_sparse_matrix A, const void *b, const int ldb, void *c, const int ldc)
void | blas_zusmm_ (const enum blas_order_type *order, const enum blas_trans_type *transA, const int *nrhs, const void *alpha, const blas_sparse_matrix *A, const void *b, const int *ldb, void *c, const int *ldc, int *istat)
int | BLAS_sussm (const enum blas_order_type order, const enum blas_trans_type transT, const int nrhs, float alpha, const blas_sparse_matrix T, float *b, const int ldb)
void | blas_sussm_ (const enum blas_order_type *order, const enum blas_trans_type *transT, const int *nrhs, float *alpha, const blas_sparse_matrix *T, float *b, const int *ldb, int *istat)
int | BLAS_dussm (const enum blas_order_type order, const enum blas_trans_type transT, const int nrhs, double alpha, const blas_sparse_matrix T, double *b, const int ldb)
void | blas_dussm_ (const enum blas_order_type *order, const enum blas_trans_type *transT, const int *nrhs, double *alpha, const blas_sparse_matrix *T, double *b, const int *ldb, int *istat)
int | BLAS_cussm (const enum blas_order_type order, const enum blas_trans_type transT, const int nrhs, const void *alpha, const blas_sparse_matrix T, void *b, const int ldb)
void | blas_cussm_ (const enum blas_order_type *order, const enum blas_trans_type *transT, const int *nrhs, const void *alpha, const blas_sparse_matrix *T, void *b, const int *ldb, int *istat)
int | BLAS_zussm (const enum blas_order_type order, const enum blas_trans_type transT, const int nrhs, const void *alpha, const blas_sparse_matrix T, void *b, const int ldb)
void | blas_zussm_ (const enum blas_order_type *order, const enum blas_trans_type *transT, const int *nrhs, const void *alpha, const blas_sparse_matrix *T, void *b, const int *ldb, int *istat)
blas_sparse_matrix | BLAS_suscr_begin (int m, int n)
void | blas_suscr_begin_ (int *m, int *n, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_duscr_begin (int m, int n)
void | blas_duscr_begin_ (int *m, int *n, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_cuscr_begin (int m, int n)
void | blas_cuscr_begin_ (int *m, int *n, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_zuscr_begin (int m, int n)
void | blas_zuscr_begin_ (int *m, int *n, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_suscr_block_begin (int Mb, int Nb, int k, int l)
void | blas_suscr_block_begin_ (int *Mb, int *Nb, int *k, int *l, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_duscr_block_begin (int Mb, int Nb, int k, int l)
void | blas_duscr_block_begin_ (int *Mb, int *Nb, int *k, int *l, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_cuscr_block_begin (int Mb, int Nb, int k, int l)
void | blas_cuscr_block_begin_ (int *Mb, int *Nb, int *k, int *l, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_zuscr_block_begin (int Mb, int Nb, int k, int l)
void | blas_zuscr_block_begin_ (int *Mb, int *Nb, int *k, int *l, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_suscr_variable_block_begin (int Mb, int Nb, const int *K, const int *L)
void | blas_suscr_variable_block_begin_ (int *Mb, int *Nb, const int *K, const int *L, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_duscr_variable_block_begin (int Mb, int Nb, const int *K, const int *L)
void | blas_duscr_variable_block_begin_ (int *Mb, int *Nb, const int *K, const int *L, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_cuscr_variable_block_begin (int Mb, int Nb, const int *K, const int *L)
void | blas_cuscr_variable_block_begin_ (int *Mb, int *Nb, const int *K, const int *L, blas_sparse_matrix *A, int *istat)
blas_sparse_matrix | BLAS_zuscr_variable_block_begin (int Mb, int Nb, const int *K, const int *L)
void | blas_zuscr_variable_block_begin_ (int *Mb, int *Nb, const int *K, const int *L, blas_sparse_matrix *A, int *istat)
int | BLAS_suscr_end (blas_sparse_matrix A)
void | blas_suscr_end_ (blas_sparse_matrix *A, int *istat)
int | BLAS_duscr_end (blas_sparse_matrix A)
void | blas_duscr_end_ (blas_sparse_matrix *A, int *istat)
int | BLAS_cuscr_end (blas_sparse_matrix A)
void | blas_cuscr_end_ (blas_sparse_matrix *A, int *istat)
int | BLAS_zuscr_end (blas_sparse_matrix A)
void | blas_zuscr_end_ (blas_sparse_matrix *A, int *istat)
int | BLAS_suscr_insert_entry (blas_sparse_matrix A, float val, int i, int j)
void | blas_suscr_insert_entry_ (blas_sparse_matrix *A, float *val, int *i, int *j, int *istat)
int | BLAS_duscr_insert_entry (blas_sparse_matrix A, double val, int i, int j)
void | blas_duscr_insert_entry_ (blas_sparse_matrix *A, double *val, int *i, int *j, int *istat)
int | BLAS_cuscr_insert_entry (blas_sparse_matrix A, const void *val, int i, int j)
void | blas_cuscr_insert_entry_ (blas_sparse_matrix *A, const void *val, int *i, int *j, int *istat)
int | BLAS_zuscr_insert_entry (blas_sparse_matrix A, const void *val, int i, int j)
void | blas_zuscr_insert_entry_ (blas_sparse_matrix *A, const void *val, int *i, int *j, int *istat)
int | BLAS_suscr_insert_entries (blas_sparse_matrix A, int nnz, const float *val, const int *indx, const int *jndx)
void | blas_suscr_insert_entries_ (blas_sparse_matrix *A, int *nnz, const float *val, const int *indx, const int *jndx, int *istat)
int | BLAS_duscr_insert_entries (blas_sparse_matrix A, int nnz, const double *val, const int *indx, const int *jndx)
void | blas_duscr_insert_entries_ (blas_sparse_matrix *A, int *nnz, const double *val, const int *indx, const int *jndx, int *istat)
int | BLAS_cuscr_insert_entries (blas_sparse_matrix A, int nnz, const void *val, const int *indx, const int *jndx)
void | blas_cuscr_insert_entries_ (blas_sparse_matrix *A, int *nnz, const void *val, const int *indx, const int *jndx, int *istat)
int | BLAS_zuscr_insert_entries (blas_sparse_matrix A, int nnz, const void *val, const int *indx, const int *jndx)
void | blas_zuscr_insert_entries_ (blas_sparse_matrix *A, int *nnz, const void *val, const int *indx, const int *jndx, int *istat)
int | BLAS_suscr_insert_col (blas_sparse_matrix A, int j, int nnz, const float *val, const int *indx)
void | blas_suscr_insert_col_ (blas_sparse_matrix *A, int *j, int *nnz, const float *val, const int *indx, int *istat)
int | BLAS_duscr_insert_col (blas_sparse_matrix A, int j, int nnz, const double *val, const int *indx)
void | blas_duscr_insert_col_ (blas_sparse_matrix *A, int *j, int *nnz, const double *val, const int *indx, int *istat)
int | BLAS_cuscr_insert_col (blas_sparse_matrix A, int j, int nnz, const void *val, const int *indx)
void | blas_cuscr_insert_col_ (blas_sparse_matrix *A, int *j, int *nnz, const void *val, const int *indx, int *istat)
int | BLAS_zuscr_insert_col (blas_sparse_matrix A, int j, int nnz, const void *val, const int *indx)
void | blas_zuscr_insert_col_ (blas_sparse_matrix *A, int *j, int *nnz, const void *val, const int *indx, int *istat)
int | BLAS_suscr_insert_row (blas_sparse_matrix A, int i, int nnz, const float *val, const int *indx)
void | blas_suscr_insert_row_ (blas_sparse_matrix *A, int *i, int *nnz, const float *val, const int *indx, int *istat)
int | BLAS_duscr_insert_row (blas_sparse_matrix A, int i, int nnz, const double *val, const int *indx)
void | blas_duscr_insert_row_ (blas_sparse_matrix *A, int *i, int *nnz, const double *val, const int *indx, int *istat)
int | BLAS_cuscr_insert_row (blas_sparse_matrix A, int i, int nnz, const void *val, const int *indx)
void | blas_cuscr_insert_row_ (blas_sparse_matrix *A, int *i, int *nnz, const void *val, const int *indx, int *istat)
int | BLAS_zuscr_insert_row (blas_sparse_matrix A, int i, int nnz, const void *val, const int *indx)
void | blas_zuscr_insert_row_ (blas_sparse_matrix *A, int *i, int *nnz, const void *val, const int *indx, int *istat)
int | BLAS_suscr_insert_clique (blas_sparse_matrix A, const int k, const int l, const float *val, const int row_stride, const int col_stride, const int *indx, const int *jndx)
void | blas_suscr_insert_clique_ (blas_sparse_matrix *A, const int *k, const int *l, const float *val, const int *row_stride, const int *col_stride, const int *indx, const int *jndx, int *istat)
int | BLAS_duscr_insert_clique (blas_sparse_matrix A, const int k, const int l, const double *val, const int row_stride, const int col_stride, const int *indx, const int *jndx)
void | blas_duscr_insert_clique_ (blas_sparse_matrix *A, const int *k, const int *l, const double *val, const int *row_stride, const int *col_stride, const int *indx, const int *jndx, int *istat)
int | BLAS_cuscr_insert_clique (blas_sparse_matrix A, const int k, const int l, const void *val, const int row_stride, const int col_stride, const int *indx, const int *jndx)
void | blas_cuscr_insert_clique_ (blas_sparse_matrix *A, const int *k, const int *l, const void *val, const int *row_stride, const int *col_stride, const int *indx, const int *jndx, int *istat)
int | BLAS_zuscr_insert_clique (blas_sparse_matrix A, const int k, const int l, const void *val, const int row_stride, const int col_stride, const int *indx, const int *jndx)
void | blas_zuscr_insert_clique_ (blas_sparse_matrix *A, const int *k, const int *l, const void *val, const int *row_stride, const int *col_stride, const int *indx, const int *jndx, int *istat)
int | BLAS_suscr_insert_block (blas_sparse_matrix A, const float *val, int row_stride, int col_stride, int i, int j)
void | blas_suscr_insert_block_ (blas_sparse_matrix *A, const float *val, int *row_stride, int *col_stride, int *i, int *j, int *istat)
int | BLAS_duscr_insert_block (blas_sparse_matrix A, const double *val, int row_stride, int col_stride, int i, int j)
void | blas_duscr_insert_block_ (blas_sparse_matrix *A, const double *val, int *row_stride, int *col_stride, int *i, int *j, int *istat)
int | BLAS_cuscr_insert_block (blas_sparse_matrix A, const void *val, int row_stride, int col_stride, int i, int j)
void | blas_cuscr_insert_block_ (blas_sparse_matrix *A, const void *val, int *row_stride, int *col_stride, int *i, int *j, int *istat)
int | BLAS_zuscr_insert_block (blas_sparse_matrix A, const void *val, int row_stride, int col_stride, int i, int j)
void | blas_zuscr_insert_block_ (blas_sparse_matrix *A, const void *val, int *row_stride, int *col_stride, int *i, int *j, int *istat)
int | BLAS_uscr_end (blas_sparse_matrix A)
void | blas_uscr_end_ (blas_sparse_matrix *A, int *istat)
int | BLAS_usds (blas_sparse_matrix A)
void | blas_usds_ (blas_sparse_matrix *A, int *istat)
int | BLAS_susrows_scale (blas_sparse_matrix A, const float *d, const enum blas_trans_type trans)
void | blas_susrows_scale_ (blas_sparse_matrix *A, const float *d, const enum blas_trans_type *trans, int *istat)
int | BLAS_dusrows_scale (blas_sparse_matrix A, const double *d, const enum blas_trans_type trans)
void | blas_dusrows_scale_ (blas_sparse_matrix *A, const double *d, const enum blas_trans_type *trans, int *istat)
int | BLAS_cusrows_scale (blas_sparse_matrix A, const void *d, const enum blas_trans_type trans)
void | blas_cusrows_scale_ (blas_sparse_matrix *A, const void *d, const enum blas_trans_type *trans, int *istat)
int | BLAS_zusrows_scale (blas_sparse_matrix A, const void *d, const enum blas_trans_type trans)
void | blas_zusrows_scale_ (blas_sparse_matrix *A, const void *d, const enum blas_trans_type *trans, int *istat)
int | BLAS_susget_diag (blas_sparse_matrix A, float *d)
void | blas_susget_diag_ (blas_sparse_matrix *A, float *d, int *istat)
int | BLAS_dusget_diag (blas_sparse_matrix A, double *d)
void | blas_dusget_diag_ (blas_sparse_matrix *A, double *d, int *istat)
int | BLAS_cusget_diag (blas_sparse_matrix A, void *d)
void | blas_cusget_diag_ (blas_sparse_matrix *A, void *d, int *istat)
int | BLAS_zusget_diag (blas_sparse_matrix A, void *d)
void | blas_zusget_diag_ (blas_sparse_matrix *A, void *d, int *istat)
int | BLAS_susget_rows_nnz (blas_sparse_matrix A, const int fr, const int lr, int *nnzp)
void | blas_susget_rows_nnz_ (blas_sparse_matrix *A, const int *fr, const int *lr, int *nnzp, int *istat)
int | BLAS_dusget_rows_nnz (blas_sparse_matrix A, const int fr, const int lr, int *nnzp)
void | blas_dusget_rows_nnz_ (blas_sparse_matrix *A, const int *fr, const int *lr, int *nnzp, int *istat)
int | BLAS_cusget_rows_nnz (blas_sparse_matrix A, const int fr, const int lr, int *nnzp)
void | blas_cusget_rows_nnz_ (blas_sparse_matrix *A, const int *fr, const int *lr, int *nnzp, int *istat)
int | BLAS_zusget_rows_nnz (blas_sparse_matrix A, const int fr, const int lr, int *nnzp)
void | blas_zusget_rows_nnz_ (blas_sparse_matrix *A, const int *fr, const int *lr, int *nnzp, int *istat)
int | BLAS_susget_rows_sparse (blas_sparse_matrix A, float *VA, int *IA, int *JA, int *nnz, const int fr, const int lr)
void | blas_susget_rows_sparse_ (blas_sparse_matrix *A, float *VA, int *IA, int *JA, int *nnz, const int *fr, const int *lr, int *istat)
int | BLAS_dusget_rows_sparse (blas_sparse_matrix A, double *VA, int *IA, int *JA, int *nnz, const int fr, const int lr)
void | blas_dusget_rows_sparse_ (blas_sparse_matrix *A, double *VA, int *IA, int *JA, int *nnz, const int *fr, const int *lr, int *istat)
int | BLAS_cusget_rows_sparse (blas_sparse_matrix A, void *VA, int *IA, int *JA, int *nnz, const int fr, const int lr)
void | blas_cusget_rows_sparse_ (blas_sparse_matrix *A, void *VA, int *IA, int *JA, int *nnz, const int *fr, const int *lr, int *istat)
int | BLAS_zusget_rows_sparse (blas_sparse_matrix A, void *VA, int *IA, int *JA, int *nnz, const int fr, const int lr)
void | blas_zusget_rows_sparse_ (blas_sparse_matrix *A, void *VA, int *IA, int *JA, int *nnz, const int *fr, const int *lr, int *istat)
int | BLAS_susget_matrix_nnz (blas_sparse_matrix A, int *nnz)
void | blas_susget_matrix_nnz_ (blas_sparse_matrix *A, int *nnz, int *istat)
int | BLAS_dusget_matrix_nnz (blas_sparse_matrix A, int *nnz)
void | blas_dusget_matrix_nnz_ (blas_sparse_matrix *A, int *nnz, int *istat)
int | BLAS_cusget_matrix_nnz (blas_sparse_matrix A, int *nnz)
void | blas_cusget_matrix_nnz_ (blas_sparse_matrix *A, int *nnz, int *istat)
int | BLAS_zusget_matrix_nnz (blas_sparse_matrix A, int *nnz)
void | blas_zusget_matrix_nnz_ (blas_sparse_matrix *A, int *nnz, int *istat)
int | BLAS_susget_infinity_norm (blas_sparse_matrix A, float *in, const enum blas_trans_type trans)
void | blas_susget_infinity_norm_ (blas_sparse_matrix *A, float *in, const enum blas_trans_type *trans, int *istat)
int | BLAS_dusget_infinity_norm (blas_sparse_matrix A, double *in, const enum blas_trans_type trans)
void | blas_dusget_infinity_norm_ (blas_sparse_matrix *A, double *in, const enum blas_trans_type *trans, int *istat)
int | BLAS_cusget_infinity_norm (blas_sparse_matrix A, void *in, const enum blas_trans_type trans)
void | blas_cusget_infinity_norm_ (blas_sparse_matrix *A, void *in, const enum blas_trans_type *trans, int *istat)
int | BLAS_zusget_infinity_norm (blas_sparse_matrix A, void *in, const enum blas_trans_type trans)
void | blas_zusget_infinity_norm_ (blas_sparse_matrix *A, void *in, const enum blas_trans_type *trans, int *istat)
int | BLAS_susset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const float *va, const int nnz)
void | blas_susset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const float *va, const int *nnz, int *istat)
int | BLAS_dusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const double *va, const int nnz)
void | blas_dusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const double *va, const int *nnz, int *istat)
int | BLAS_cusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const void *va, const int nnz)
void | blas_cusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const void *va, const int *nnz, int *istat)
int | BLAS_zusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const void *va, const int nnz)
void | blas_zusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const void *va, const int *nnz, int *istat)
int | BLAS_susset_element (blas_sparse_matrix A, const int i, const int j, float *v)
void | blas_susset_element_ (blas_sparse_matrix *A, const int *i, const int *j, float *v, int *istat)
int | BLAS_dusset_element (blas_sparse_matrix A, const int i, const int j, double *v)
void | blas_dusset_element_ (blas_sparse_matrix *A, const int *i, const int *j, double *v, int *istat)
int | BLAS_cusset_element (blas_sparse_matrix A, const int i, const int j, void *v)
void | blas_cusset_element_ (blas_sparse_matrix *A, const int *i, const int *j, void *v, int *istat)
int | BLAS_zusset_element (blas_sparse_matrix A, const int i, const int j, void *v)
void | blas_zusset_element_ (blas_sparse_matrix *A, const int *i, const int *j, void *v, int *istat)
int | BLAS_susget_element (blas_sparse_matrix A, const int i, const int j, float *v)
void | blas_susget_element_ (blas_sparse_matrix *A, const int *i, const int *j, float *v, int *istat)
int | BLAS_dusget_element (blas_sparse_matrix A, const int i, const int j, double *v)
void | blas_dusget_element_ (blas_sparse_matrix *A, const int *i, const int *j, double *v, int *istat)
int | BLAS_cusget_element (blas_sparse_matrix A, const int i, const int j, void *v)
void | blas_cusget_element_ (blas_sparse_matrix *A, const int *i, const int *j, void *v, int *istat)
int | BLAS_zusget_element (blas_sparse_matrix A, const int i, const int j, void *v)
void | blas_zusget_element_ (blas_sparse_matrix *A, const int *i, const int *j, void *v, int *istat)
int | BLAS_usgp (blas_sparse_matrix A, rsb_blas_pname_t pname)
void | blas_usgp_ (blas_sparse_matrix *A, rsb_blas_pname_t *pname, int *istat)
void | blas_ussp_ (blas_sparse_matrix *A, rsb_blas_pname_t *pname, int *istat)
int | BLAS_ussp (blas_sparse_matrix A, rsb_blas_pname_t pname)
blas_sparse_matrix | rsb_blas_file_mtx_load (const rsb_char_t *filename, rsb_type_t typecode)
struct rsb_mtx_t * | rsb_blas_get_mtx (blas_sparse_matrix A)

## Detailed Description

A Sparse BLAS interface (see http://www.netlib.org/blas/blast-forum/) to `librsb`. Level 1 (vector-vector operations) is supported in a basic way. Level 2 (sparse matrix-dense vector operations) is supported fully. Level 3 (sparse matrix-dense matrix operations) is supported as a wrapper around Level 2.

We also implement a number of useful extra functions as custom extensions, giving access to other `librsb` functionality.

The usage pattern of this interface matches that of the Sparse BLAS standard, exception made for the necessity of initialization/finalization of `librsb`. The Sparse BLAS interface is also available for Fortran: see rsb_blas_sparse.F90.

The user should be aware of the following:

- Because this Sparse BLAS implementation is built around `librsb`, initialization with rsb_lib_init() and finalization with rsb_lib_exit() is necessary. Inclusion of the `rsb.h` header is necessary.
- `librsb` gives users freedom of in/out arbitrarily BLAS types support at configure/build time. Hence, while all the interface functions are always included the Sparse BLAS header file, they may return an error code. Be sure of having configured correctly the library at configure time (and see the blas_sparse.h header file for types configured in the current build).
- According to the standard, the complex type functions for C accept scalar values by reference rather than by copy; equivalent functions for other types do not do so, so this may cause confusion. Be careful.
- Error checking is weak; so for instance, passing a function the handle of a matrix of mismatching type will not be detected as an error, although it's incorrect.
- According to the standard, VBR and BCSR styled constructors are supported, although these are interfaces for `librsb's` own matrix representation.
- Here functions for both Fortran and C are listed. The Fortran functions are declared and documented with the C notation. We may provide a better documentation in a future release.
- Each identifier documented here suffixed by `_` (e.g.: blas_susdot_()) can be used from Fortran with the name stripped by that suffix (so in this case, `blas_susdot`). We may provide a proper fix to this inconvenience in a subsequent release.
- Each Fortran program using `librsb's` Sparse BLAS Implementation shall `use` modules `blas_sparse` and `rsb`.
- Also Fortran programs have to call rsb_lib_init() and rsb_lib_exit() e.g.:

              USE blas_sparse             ! module implementing the Sparse BLAS on the top of librsb
              USE rsb                     ! rsb module
              ...
              INTEGER :: istat            ! integer variable
              ...
              istat = rsb_lib_init(RSB_NULL_INIT_OPTIONS) ! please note that this is not part of Sparse BLAS but it is needed by librsb
              if(istat.NE.0)STOP          ! a value different than zero signals an error
              ...
              ! code calling Sparse BLAS routines
              ...
              istat = rsb_lib_exit(RSB_NULL_EXIT_OPTIONS) ! please note that this is not part of Sparse BLAS but it is needed by librsb
              if(istat.NE.0)STOP          ! a value different than zero signals an error
              ...

- For Fortran, more procedures exist, although they are not documented here. According to the Sparse BLAS (http://www.netlib.org/blas/blast-forum/), for almost each subroutine whose identifier prefixed with `blas_X` (with `X` being one of S,D,C,Z), a corresponding generic modern Fortran version exists. Please note how not all of the certain procedures identifier prefixes include the type character.

E.g.:

! the following code ('d' stays for 'double precision'):
CALL blas_duscr_begin(nr,nc,A,istat)
CALL blas_ussp(A,blas_lower_symmetric,istat)
CALL blas_duscr_insert_entries(A,nnz,VA,IA,JA,istat)
CALL blas_duscr_end(A,istat)
CALL blas_dusmv(transT,alpha,A,X,incX,B,incB,istat)
CALL blas_dusds(A,istat)
! is equivalent to:
CALL duscr_begin(nr,nc,A,istat) ! here, 'd' must be retained for avoiding ambiguity
CALL ussp(A,blas_lower_symmetric,istat)
CALL uscr_insert_entries(A,nnz,VA,IA,JA,istat)
CALL uscr_end(A,istat)
CALL usmv(transT,alpha,A,X,incX,B,incB,istat)
CALL usds(A,istat)
bench
void bench(const std::string filename, rsb_flags_t order)
Definition autotune.cpp:42
blas_lower_symmetric
@ blas_lower_symmetric
Definition blas_sparse.h:113

## Function Documentation

## BLAS_cusaxpy()

int BLAS_cusaxpy | ( | const int | nnz,
|  | const void * | alpha,
|  | const void * | x,
|  | const int * | indx,
|  | void * | y,
|  | const int | incy,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_cusaxpy_()

void blas_cusaxpy_ | ( | const int * | nnz,
|  | const void * | alpha,
|  | const void * | x,
|  | const int * | indx,
|  | void * | y,
|  | const int * | incy,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_cuscr_begin()

blas_sparse_matrix BLAS_cuscr_begin | ( | int | m,
|  | int | n
| ) |  |

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.

## blas_cuscr_begin_()

void blas_cuscr_begin_ | ( | int * | m,
|  | int * | n,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_cuscr_block_begin()

blas_sparse_matrix BLAS_cuscr_block_begin | ( | int | Mb,
|  | int | Nb,
|  | int | k,
|  | int | l
| ) |  |

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.

## blas_cuscr_block_begin_()

void blas_cuscr_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | int * | k,
|  | int * | l,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_cuscr_end()

int BLAS_cuscr_end | ( | blas_sparse_matrix | A | ) |

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.

## blas_cuscr_end_()

void blas_cuscr_end_ | ( | blas_sparse_matrix * | A,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_block()

int BLAS_cuscr_insert_block | ( | blas_sparse_matrix | A,
|  | const void * | val,
|  | int | row_stride,
|  | int | col_stride,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_cuscr_insert_block_()

void blas_cuscr_insert_block_ | ( | blas_sparse_matrix * | A,
|  | const void * | val,
|  | int * | row_stride,
|  | int * | col_stride,
|  | int * | i,
|  | int * | j,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_clique()

int BLAS_cuscr_insert_clique | ( | blas_sparse_matrix | A,
|  | const int | k,
|  | const int | l,
|  | const void * | val,
|  | const int | row_stride,
|  | const int | col_stride,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_cuscr_insert_clique_()

void blas_cuscr_insert_clique_ | ( | blas_sparse_matrix * | A,
|  | const int * | k,
|  | const int * | l,
|  | const void * | val,
|  | const int * | row_stride,
|  | const int * | col_stride,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_col()

int BLAS_cuscr_insert_col | ( | blas_sparse_matrix | A,
|  | int | j,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx
| ) |  |

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.

## blas_cuscr_insert_col_()

void blas_cuscr_insert_col_ | ( | blas_sparse_matrix * | A,
|  | int * | j,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_entries()

int BLAS_cuscr_insert_entries | ( | blas_sparse_matrix | A,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_cuscr_insert_entries_()

void blas_cuscr_insert_entries_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_entry()

int BLAS_cuscr_insert_entry | ( | blas_sparse_matrix | A,
|  | const void * | val,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_cuscr_insert_entry_()

void blas_cuscr_insert_entry_ | ( | blas_sparse_matrix * | A,
|  | const void * | val,
|  | int * | i,
|  | int * | j,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_insert_row()

int BLAS_cuscr_insert_row | ( | blas_sparse_matrix | A,
|  | int | i,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx
| ) |  |

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.

## blas_cuscr_insert_row_()

void blas_cuscr_insert_row_ | ( | blas_sparse_matrix * | A,
|  | int * | i,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cuscr_variable_block_begin()

blas_sparse_matrix BLAS_cuscr_variable_block_begin | ( | int | Mb,
|  | int | Nb,
|  | const int * | K,
|  | const int * | L
| ) |  |

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.

## blas_cuscr_variable_block_begin_()

void blas_cuscr_variable_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | const int * | K,
|  | const int * | L,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_cusdot()

int BLAS_cusdot | ( | const enum blas_conj_type | conj,
|  | const int | nnz,
|  | const void * | x,
|  | const int * | indx,
|  | const void * | y,
|  | const int | incy,
|  | void * | r,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_cusdot_()

void blas_cusdot_ | ( | const enum blas_conj_type * | conj,
|  | const int * | nnz,
|  | const void * | x,
|  | const int * | indx,
|  | const void * | y,
|  | const int * | incy,
|  | void * | r,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_cusga()

int BLAS_cusga | ( | const int | nnz,
|  | const void * | y,
|  | const int | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_cusga_()

void blas_cusga_ | ( | const int * | nnz,
|  | const void * | y,
|  | const int * | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_cusget_diag()

int BLAS_cusget_diag | ( | blas_sparse_matrix | A,
|  | void * | d
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_diag_()

void blas_cusget_diag_ | ( | blas_sparse_matrix * | A,
|  | void * | d,
|  | int * | istat
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusget_element()

int BLAS_cusget_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | void * | v
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_element_()

void blas_cusget_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | void * | v,
|  | int * | istat
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusget_infinity_norm()

int BLAS_cusget_infinity_norm | ( | blas_sparse_matrix | A,
|  | void * | in,
|  | const enum blas_trans_type | trans
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_infinity_norm_()

void blas_cusget_infinity_norm_ | ( | blas_sparse_matrix * | A,
|  | void * | in,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusget_matrix_nnz()

int BLAS_cusget_matrix_nnz | ( | blas_sparse_matrix | A,
|  | int * | nnz
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_matrix_nnz_()

void blas_cusget_matrix_nnz_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | int * | istat
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusget_rows_nnz()

int BLAS_cusget_rows_nnz | ( | blas_sparse_matrix | A,
|  | const int | fr,
|  | const int | lr,
|  | int * | nnzp
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_rows_nnz_()

void blas_cusget_rows_nnz_ | ( | blas_sparse_matrix * | A,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | nnzp,
|  | int * | istat
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusget_rows_sparse()

int BLAS_cusget_rows_sparse | ( | blas_sparse_matrix | A,
|  | void * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int | fr,
|  | const int | lr
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusget_rows_sparse_()

void blas_cusget_rows_sparse_ | ( | blas_sparse_matrix * | A,
|  | void * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | istat
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusgz()

int BLAS_cusgz | ( | const int | nnz,
|  | void * | y,
|  | const int | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_cusgz_()

void blas_cusgz_ | ( | const int * | nnz,
|  | void * | y,
|  | const int * | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_cusmm()

int BLAS_cusmm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transA,
|  | const int | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix | A,
|  | const void * | b,
|  | const int | ldb,
|  | void * | c,
|  | const int | ldc
| ) |  |

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.

## blas_cusmm_()

void blas_cusmm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transA,
|  | const int * | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const void * | b,
|  | const int * | ldb,
|  | void * | c,
|  | const int * | ldc,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusmv()

int BLAS_cusmv | ( | const enum blas_trans_type | transA,
|  | const void * | alpha,
|  | const blas_sparse_matrix | A,
|  | const void * | x,
|  | const int | incx,
|  | void * | y,
|  | const int | incy
| ) |  |

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.

## blas_cusmv_()

void blas_cusmv_ | ( | const enum blas_trans_type * | transA,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const void * | x,
|  | const int * | incx,
|  | void * | y,
|  | const int * | incy,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusrows_scale()

int BLAS_cusrows_scale | ( | blas_sparse_matrix | A,
|  | const void * | d,
|  | const enum blas_trans_type | trans
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusrows_scale_()

void blas_cusrows_scale_ | ( | blas_sparse_matrix * | A,
|  | const void * | d,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cussc()

int BLAS_cussc | ( | const int | nnz,
|  | const void * | x,
|  | void * | y,
|  | const int | incy,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_cussc_()

void blas_cussc_ | ( | const int * | nnz,
|  | const void * | x,
|  | void * | y,
|  | const int * | incy,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_cusset_element()

int BLAS_cusset_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | void * | v
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_cusset_element_()

void blas_cusset_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | void * | v,
|  | int * | istat
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cusset_elements()

int BLAS_cusset_elements | ( | blas_sparse_matrix | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const void * | va,
|  | const int | nnz
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

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

## blas_cusset_elements_()

void blas_cusset_elements_ | ( | blas_sparse_matrix * | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const void * | va,
|  | const int * | nnz,
|  | int * | istat
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cussm()

int BLAS_cussm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transT,
|  | const int | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix | T,
|  | void * | b,
|  | const int | ldb
| ) |  |

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.

## blas_cussm_()

void blas_cussm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transT,
|  | const int * | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | T,
|  | void * | b,
|  | const int * | ldb,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_cussv()

int BLAS_cussv | ( | enum blas_trans_type | transT,
|  | const void * | alpha,
|  | const blas_sparse_matrix | T,
|  | void * | x,
|  | const int | incx
| ) |  |

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.

## blas_cussv_()

void blas_cussv_ | ( | enum blas_trans_type * | transT,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | T,
|  | void * | x,
|  | const int * | incx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusaxpy()

int BLAS_dusaxpy | ( | const int | nnz,
|  | double | alpha,
|  | const double * | x,
|  | const int * | indx,
|  | double * | y,
|  | const int | incy,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_dusaxpy_()

void blas_dusaxpy_ | ( | const int * | nnz,
|  | double * | alpha,
|  | const double * | x,
|  | const int * | indx,
|  | double * | y,
|  | const int * | incy,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_duscr_begin()

blas_sparse_matrix BLAS_duscr_begin | ( | int | m,
|  | int | n
| ) |  |

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.

## blas_duscr_begin_()

void blas_duscr_begin_ | ( | int * | m,
|  | int * | n,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_duscr_block_begin()

blas_sparse_matrix BLAS_duscr_block_begin | ( | int | Mb,
|  | int | Nb,
|  | int | k,
|  | int | l
| ) |  |

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.

## blas_duscr_block_begin_()

void blas_duscr_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | int * | k,
|  | int * | l,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_duscr_end()

int BLAS_duscr_end | ( | blas_sparse_matrix | A | ) |

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.

## blas_duscr_end_()

void blas_duscr_end_ | ( | blas_sparse_matrix * | A,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_block()

int BLAS_duscr_insert_block | ( | blas_sparse_matrix | A,
|  | const double * | val,
|  | int | row_stride,
|  | int | col_stride,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_duscr_insert_block_()

void blas_duscr_insert_block_ | ( | blas_sparse_matrix * | A,
|  | const double * | val,
|  | int * | row_stride,
|  | int * | col_stride,
|  | int * | i,
|  | int * | j,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_clique()

int BLAS_duscr_insert_clique | ( | blas_sparse_matrix | A,
|  | const int | k,
|  | const int | l,
|  | const double * | val,
|  | const int | row_stride,
|  | const int | col_stride,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_duscr_insert_clique_()

void blas_duscr_insert_clique_ | ( | blas_sparse_matrix * | A,
|  | const int * | k,
|  | const int * | l,
|  | const double * | val,
|  | const int * | row_stride,
|  | const int * | col_stride,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_col()

int BLAS_duscr_insert_col | ( | blas_sparse_matrix | A,
|  | int | j,
|  | int | nnz,
|  | const double * | val,
|  | const int * | indx
| ) |  |

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.

## blas_duscr_insert_col_()

void blas_duscr_insert_col_ | ( | blas_sparse_matrix * | A,
|  | int * | j,
|  | int * | nnz,
|  | const double * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_entries()

int BLAS_duscr_insert_entries | ( | blas_sparse_matrix | A,
|  | int | nnz,
|  | const double * | val,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_duscr_insert_entries_()

void blas_duscr_insert_entries_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | const double * | val,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_entry()

int BLAS_duscr_insert_entry | ( | blas_sparse_matrix | A,
|  | double | val,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_duscr_insert_entry_()

void blas_duscr_insert_entry_ | ( | blas_sparse_matrix * | A,
|  | double * | val,
|  | int * | i,
|  | int * | j,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_insert_row()

int BLAS_duscr_insert_row | ( | blas_sparse_matrix | A,
|  | int | i,
|  | int | nnz,
|  | const double * | val,
|  | const int * | indx
| ) |  |

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.

## blas_duscr_insert_row_()

void blas_duscr_insert_row_ | ( | blas_sparse_matrix * | A,
|  | int * | i,
|  | int * | nnz,
|  | const double * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_duscr_variable_block_begin()

blas_sparse_matrix BLAS_duscr_variable_block_begin | ( | int | Mb,
|  | int | Nb,
|  | const int * | K,
|  | const int * | L
| ) |  |

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.

## blas_duscr_variable_block_begin_()

void blas_duscr_variable_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | const int * | K,
|  | const int * | L,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_dusdot()

int BLAS_dusdot | ( | const enum blas_conj_type | conj,
|  | const int | nnz,
|  | const double * | x,
|  | const int * | indx,
|  | const double * | y,
|  | const int | incy,
|  | double * | r,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_dusdot_()

void blas_dusdot_ | ( | const enum blas_conj_type * | conj,
|  | const int * | nnz,
|  | const double * | x,
|  | const int * | indx,
|  | const double * | y,
|  | const int * | incy,
|  | double * | r,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_dusga()

int BLAS_dusga | ( | const int | nnz,
|  | const double * | y,
|  | const int | incy,
|  | double * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_dusga_()

void blas_dusga_ | ( | const int * | nnz,
|  | const double * | y,
|  | const int * | incy,
|  | double * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_dusget_diag()

int BLAS_dusget_diag | ( | blas_sparse_matrix | A,
|  | double * | d
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_diag_()

void blas_dusget_diag_ | ( | blas_sparse_matrix * | A,
|  | double * | d,
|  | int * | istat
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusget_element()

int BLAS_dusget_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | double * | v
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_element_()

void blas_dusget_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | double * | v,
|  | int * | istat
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusget_infinity_norm()

int BLAS_dusget_infinity_norm | ( | blas_sparse_matrix | A,
|  | double * | in,
|  | const enum blas_trans_type | trans
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_infinity_norm_()

void blas_dusget_infinity_norm_ | ( | blas_sparse_matrix * | A,
|  | double * | in,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusget_matrix_nnz()

int BLAS_dusget_matrix_nnz | ( | blas_sparse_matrix | A,
|  | int * | nnz
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_matrix_nnz_()

void blas_dusget_matrix_nnz_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | int * | istat
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusget_rows_nnz()

int BLAS_dusget_rows_nnz | ( | blas_sparse_matrix | A,
|  | const int | fr,
|  | const int | lr,
|  | int * | nnzp
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_rows_nnz_()

void blas_dusget_rows_nnz_ | ( | blas_sparse_matrix * | A,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | nnzp,
|  | int * | istat
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusget_rows_sparse()

int BLAS_dusget_rows_sparse | ( | blas_sparse_matrix | A,
|  | double * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int | fr,
|  | const int | lr
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusget_rows_sparse_()

void blas_dusget_rows_sparse_ | ( | blas_sparse_matrix * | A,
|  | double * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | istat
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusgz()

int BLAS_dusgz | ( | const int | nnz,
|  | double * | y,
|  | const int | incy,
|  | double * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_dusgz_()

void blas_dusgz_ | ( | const int * | nnz,
|  | double * | y,
|  | const int * | incy,
|  | double * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_dusmm()

int BLAS_dusmm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transA,
|  | const int | nrhs,
|  | double | alpha,
|  | const blas_sparse_matrix | A,
|  | const double * | b,
|  | const int | ldb,
|  | double * | c,
|  | const int | ldc
| ) |  |

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.

## blas_dusmm_()

void blas_dusmm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transA,
|  | const int * | nrhs,
|  | double * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const double * | b,
|  | const int * | ldb,
|  | double * | c,
|  | const int * | ldc,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusmv()

int BLAS_dusmv | ( | const enum blas_trans_type | transA,
|  | double | alpha,
|  | const blas_sparse_matrix | A,
|  | const double * | x,
|  | const int | incx,
|  | double * | y,
|  | const int | incy
| ) |  |

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.

## blas_dusmv_()

void blas_dusmv_ | ( | const enum blas_trans_type * | transA,
|  | double * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const double * | x,
|  | const int * | incx,
|  | double * | y,
|  | const int * | incy,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusrows_scale()

int BLAS_dusrows_scale | ( | blas_sparse_matrix | A,
|  | const double * | d,
|  | const enum blas_trans_type | trans
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusrows_scale_()

void blas_dusrows_scale_ | ( | blas_sparse_matrix * | A,
|  | const double * | d,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dussc()

int BLAS_dussc | ( | const int | nnz,
|  | const double * | x,
|  | double * | y,
|  | const int | incy,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_dussc_()

void blas_dussc_ | ( | const int * | nnz,
|  | const double * | x,
|  | double * | y,
|  | const int * | incy,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_dusset_element()

int BLAS_dusset_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | double * | v
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_dusset_element_()

void blas_dusset_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | double * | v,
|  | int * | istat
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dusset_elements()

int BLAS_dusset_elements | ( | blas_sparse_matrix | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const double * | va,
|  | const int | nnz
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

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

## blas_dusset_elements_()

void blas_dusset_elements_ | ( | blas_sparse_matrix * | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const double * | va,
|  | const int * | nnz,
|  | int * | istat
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dussm()

int BLAS_dussm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transT,
|  | const int | nrhs,
|  | double | alpha,
|  | const blas_sparse_matrix | T,
|  | double * | b,
|  | const int | ldb
| ) |  |

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.

## blas_dussm_()

void blas_dussm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transT,
|  | const int * | nrhs,
|  | double * | alpha,
|  | const blas_sparse_matrix * | T,
|  | double * | b,
|  | const int * | ldb,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_dussv()

int BLAS_dussv | ( | enum blas_trans_type | transT,
|  | double | alpha,
|  | const blas_sparse_matrix | T,
|  | double * | x,
|  | const int | incx
| ) |  |

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.

## blas_dussv_()

void blas_dussv_ | ( | enum blas_trans_type * | transT,
|  | double * | alpha,
|  | const blas_sparse_matrix * | T,
|  | double * | x,
|  | const int * | incx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susaxpy()

int BLAS_susaxpy | ( | const int | nnz,
|  | float | alpha,
|  | const float * | x,
|  | const int * | indx,
|  | float * | y,
|  | const int | incy,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_susaxpy_()

void blas_susaxpy_ | ( | const int * | nnz,
|  | float * | alpha,
|  | const float * | x,
|  | const int * | indx,
|  | float * | y,
|  | const int * | incy,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_suscr_begin()

blas_sparse_matrix BLAS_suscr_begin | ( | int | m,
|  | int | n
| ) |  |

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.

## blas_suscr_begin_()

void blas_suscr_begin_ | ( | int * | m,
|  | int * | n,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_suscr_block_begin()

blas_sparse_matrix BLAS_suscr_block_begin | ( | int | Mb,
|  | int | Nb,
|  | int | k,
|  | int | l
| ) |  |

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.

## blas_suscr_block_begin_()

void blas_suscr_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | int * | k,
|  | int * | l,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_suscr_end()

int BLAS_suscr_end | ( | blas_sparse_matrix | A | ) |

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.

## blas_suscr_end_()

void blas_suscr_end_ | ( | blas_sparse_matrix * | A,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_block()

int BLAS_suscr_insert_block | ( | blas_sparse_matrix | A,
|  | const float * | val,
|  | int | row_stride,
|  | int | col_stride,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_suscr_insert_block_()

void blas_suscr_insert_block_ | ( | blas_sparse_matrix * | A,
|  | const float * | val,
|  | int * | row_stride,
|  | int * | col_stride,
|  | int * | i,
|  | int * | j,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_clique()

int BLAS_suscr_insert_clique | ( | blas_sparse_matrix | A,
|  | const int | k,
|  | const int | l,
|  | const float * | val,
|  | const int | row_stride,
|  | const int | col_stride,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_suscr_insert_clique_()

void blas_suscr_insert_clique_ | ( | blas_sparse_matrix * | A,
|  | const int * | k,
|  | const int * | l,
|  | const float * | val,
|  | const int * | row_stride,
|  | const int * | col_stride,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_col()

int BLAS_suscr_insert_col | ( | blas_sparse_matrix | A,
|  | int | j,
|  | int | nnz,
|  | const float * | val,
|  | const int * | indx
| ) |  |

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.

## blas_suscr_insert_col_()

void blas_suscr_insert_col_ | ( | blas_sparse_matrix * | A,
|  | int * | j,
|  | int * | nnz,
|  | const float * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_entries()

int BLAS_suscr_insert_entries | ( | blas_sparse_matrix | A,
|  | int | nnz,
|  | const float * | val,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_suscr_insert_entries_()

void blas_suscr_insert_entries_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | const float * | val,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_entry()

int BLAS_suscr_insert_entry | ( | blas_sparse_matrix | A,
|  | float | val,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_suscr_insert_entry_()

void blas_suscr_insert_entry_ | ( | blas_sparse_matrix * | A,
|  | float * | val,
|  | int * | i,
|  | int * | j,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_insert_row()

int BLAS_suscr_insert_row | ( | blas_sparse_matrix | A,
|  | int | i,
|  | int | nnz,
|  | const float * | val,
|  | const int * | indx
| ) |  |

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.

## blas_suscr_insert_row_()

void blas_suscr_insert_row_ | ( | blas_sparse_matrix * | A,
|  | int * | i,
|  | int * | nnz,
|  | const float * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_suscr_variable_block_begin()

blas_sparse_matrix BLAS_suscr_variable_block_begin | ( | int | Mb,
|  | int | Nb,
|  | const int * | K,
|  | const int * | L
| ) |  |

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.

## blas_suscr_variable_block_begin_()

void blas_suscr_variable_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | const int * | K,
|  | const int * | L,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_susdot()

int BLAS_susdot | ( | const enum blas_conj_type | conj,
|  | const int | nnz,
|  | const float * | x,
|  | const int * | indx,
|  | const float * | y,
|  | const int | incy,
|  | float * | r,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_susdot_()

void blas_susdot_ | ( | const enum blas_conj_type * | conj,
|  | const int * | nnz,
|  | const float * | x,
|  | const int * | indx,
|  | const float * | y,
|  | const int * | incy,
|  | float * | r,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_susga()

int BLAS_susga | ( | const int | nnz,
|  | const float * | y,
|  | const int | incy,
|  | float * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_susga_()

void blas_susga_ | ( | const int * | nnz,
|  | const float * | y,
|  | const int * | incy,
|  | float * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_susget_diag()

int BLAS_susget_diag | ( | blas_sparse_matrix | A,
|  | float * | d
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_diag_()

void blas_susget_diag_ | ( | blas_sparse_matrix * | A,
|  | float * | d,
|  | int * | istat
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susget_element()

int BLAS_susget_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | float * | v
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_element_()

void blas_susget_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | float * | v,
|  | int * | istat
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susget_infinity_norm()

int BLAS_susget_infinity_norm | ( | blas_sparse_matrix | A,
|  | float * | in,
|  | const enum blas_trans_type | trans
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_infinity_norm_()

void blas_susget_infinity_norm_ | ( | blas_sparse_matrix * | A,
|  | float * | in,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susget_matrix_nnz()

int BLAS_susget_matrix_nnz | ( | blas_sparse_matrix | A,
|  | int * | nnz
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_matrix_nnz_()

void blas_susget_matrix_nnz_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | int * | istat
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susget_rows_nnz()

int BLAS_susget_rows_nnz | ( | blas_sparse_matrix | A,
|  | const int | fr,
|  | const int | lr,
|  | int * | nnzp
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_rows_nnz_()

void blas_susget_rows_nnz_ | ( | blas_sparse_matrix * | A,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | nnzp,
|  | int * | istat
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susget_rows_sparse()

int BLAS_susget_rows_sparse | ( | blas_sparse_matrix | A,
|  | float * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int | fr,
|  | const int | lr
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susget_rows_sparse_()

void blas_susget_rows_sparse_ | ( | blas_sparse_matrix * | A,
|  | float * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | istat
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susgz()

int BLAS_susgz | ( | const int | nnz,
|  | float * | y,
|  | const int | incy,
|  | float * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_susgz_()

void blas_susgz_ | ( | const int * | nnz,
|  | float * | y,
|  | const int * | incy,
|  | float * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_susmm()

int BLAS_susmm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transA,
|  | const int | nrhs,
|  | float | alpha,
|  | const blas_sparse_matrix | A,
|  | const float * | b,
|  | const int | ldb,
|  | float * | c,
|  | const int | ldc
| ) |  |

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.

## blas_susmm_()

void blas_susmm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transA,
|  | const int * | nrhs,
|  | float * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const float * | b,
|  | const int * | ldb,
|  | float * | c,
|  | const int * | ldc,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susmv()

int BLAS_susmv | ( | const enum blas_trans_type | transA,
|  | float | alpha,
|  | const blas_sparse_matrix | A,
|  | const float * | x,
|  | const int | incx,
|  | float * | y,
|  | const int | incy
| ) |  |

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.

## blas_susmv_()

void blas_susmv_ | ( | const enum blas_trans_type * | transA,
|  | float * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const float * | x,
|  | const int * | incx,
|  | float * | y,
|  | const int * | incy,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susrows_scale()

int BLAS_susrows_scale | ( | blas_sparse_matrix | A,
|  | const float * | d,
|  | const enum blas_trans_type | trans
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susrows_scale_()

void blas_susrows_scale_ | ( | blas_sparse_matrix * | A,
|  | const float * | d,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_sussc()

int BLAS_sussc | ( | const int | nnz,
|  | const float * | x,
|  | float * | y,
|  | const int | incy,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_sussc_()

void blas_sussc_ | ( | const int * | nnz,
|  | const float * | x,
|  | float * | y,
|  | const int * | incy,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_susset_element()

int BLAS_susset_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | float * | v
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_susset_element_()

void blas_susset_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | float * | v,
|  | int * | istat
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_susset_elements()

int BLAS_susset_elements | ( | blas_sparse_matrix | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const float * | va,
|  | const int | nnz
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

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

## blas_susset_elements_()

void blas_susset_elements_ | ( | blas_sparse_matrix * | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const float * | va,
|  | const int * | nnz,
|  | int * | istat
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_sussm()

int BLAS_sussm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transT,
|  | const int | nrhs,
|  | float | alpha,
|  | const blas_sparse_matrix | T,
|  | float * | b,
|  | const int | ldb
| ) |  |

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.

## blas_sussm_()

void blas_sussm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transT,
|  | const int * | nrhs,
|  | float * | alpha,
|  | const blas_sparse_matrix * | T,
|  | float * | b,
|  | const int * | ldb,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_sussv()

int BLAS_sussv | ( | enum blas_trans_type | transT,
|  | float | alpha,
|  | const blas_sparse_matrix | T,
|  | float * | x,
|  | const int | incx
| ) |  |

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.

## blas_sussv_()

void blas_sussv_ | ( | enum blas_trans_type * | transT,
|  | float * | alpha,
|  | const blas_sparse_matrix * | T,
|  | float * | x,
|  | const int * | incx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_uscr_end()

int BLAS_uscr_end | ( | blas_sparse_matrix | A | ) |

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.

## blas_uscr_end_()

void blas_uscr_end_ | ( | blas_sparse_matrix * | A,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_usds()

int BLAS_usds | ( | blas_sparse_matrix | A | ) |

Destroys a matrix.

Parameters

  A | A valid matrix handle.

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

## blas_usds_()

void blas_usds_ | ( | blas_sparse_matrix * | A,
|  | int * | istat
| ) |  |

Destroys a matrix.

Parameters

  A | A valid matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_usgp()

int BLAS_usgp | ( | blas_sparse_matrix | A,
|  | rsb_blas_pname_t | pname
| ) |  |

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.

## blas_usgp_()

void blas_usgp_ | ( | blas_sparse_matrix * | A,
|  | rsb_blas_pname_t * | pname,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_ussp()

int BLAS_ussp | ( | blas_sparse_matrix | A,
|  | rsb_blas_pname_t | pname
| ) |  |

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.

## blas_ussp_()

void blas_ussp_ | ( | blas_sparse_matrix * | A,
|  | rsb_blas_pname_t * | pname,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusaxpy()

int BLAS_zusaxpy | ( | const int | nnz,
|  | const void * | alpha,
|  | const void * | x,
|  | const int * | indx,
|  | void * | y,
|  | const int | incy,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_zusaxpy_()

void blas_zusaxpy_ | ( | const int * | nnz,
|  | const void * | alpha,
|  | const void * | x,
|  | const int * | indx,
|  | void * | y,
|  | const int * | incy,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse vector update: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  alpha | Will scale values of before accumulating to .
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_zuscr_begin()

blas_sparse_matrix BLAS_zuscr_begin | ( | int | m,
|  | int | n
| ) |  |

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.

## blas_zuscr_begin_()

void blas_zuscr_begin_ | ( | int * | m,
|  | int * | n,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_zuscr_block_begin()

blas_sparse_matrix BLAS_zuscr_block_begin | ( | int | Mb,
|  | int | Nb,
|  | int | k,
|  | int | l
| ) |  |

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.

## blas_zuscr_block_begin_()

void blas_zuscr_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | int * | k,
|  | int * | l,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_zuscr_end()

int BLAS_zuscr_end | ( | blas_sparse_matrix | A | ) |

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.

## blas_zuscr_end_()

void blas_zuscr_end_ | ( | blas_sparse_matrix * | A,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_block()

int BLAS_zuscr_insert_block | ( | blas_sparse_matrix | A,
|  | const void * | val,
|  | int | row_stride,
|  | int | col_stride,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_zuscr_insert_block_()

void blas_zuscr_insert_block_ | ( | blas_sparse_matrix * | A,
|  | const void * | val,
|  | int * | row_stride,
|  | int * | col_stride,
|  | int * | i,
|  | int * | j,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_clique()

int BLAS_zuscr_insert_clique | ( | blas_sparse_matrix | A,
|  | const int | k,
|  | const int | l,
|  | const void * | val,
|  | const int | row_stride,
|  | const int | col_stride,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_zuscr_insert_clique_()

void blas_zuscr_insert_clique_ | ( | blas_sparse_matrix * | A,
|  | const int * | k,
|  | const int * | l,
|  | const void * | val,
|  | const int * | row_stride,
|  | const int * | col_stride,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_col()

int BLAS_zuscr_insert_col | ( | blas_sparse_matrix | A,
|  | int | j,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx
| ) |  |

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.

## blas_zuscr_insert_col_()

void blas_zuscr_insert_col_ | ( | blas_sparse_matrix * | A,
|  | int * | j,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_entries()

int BLAS_zuscr_insert_entries | ( | blas_sparse_matrix | A,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | const int * | jndx
| ) |  |

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.

## blas_zuscr_insert_entries_()

void blas_zuscr_insert_entries_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | const int * | jndx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_entry()

int BLAS_zuscr_insert_entry | ( | blas_sparse_matrix | A,
|  | const void * | val,
|  | int | i,
|  | int | j
| ) |  |

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.

## blas_zuscr_insert_entry_()

void blas_zuscr_insert_entry_ | ( | blas_sparse_matrix * | A,
|  | const void * | val,
|  | int * | i,
|  | int * | j,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_insert_row()

int BLAS_zuscr_insert_row | ( | blas_sparse_matrix | A,
|  | int | i,
|  | int | nnz,
|  | const void * | val,
|  | const int * | indx
| ) |  |

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.

## blas_zuscr_insert_row_()

void blas_zuscr_insert_row_ | ( | blas_sparse_matrix * | A,
|  | int * | i,
|  | int * | nnz,
|  | const void * | val,
|  | const int * | indx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zuscr_variable_block_begin()

blas_sparse_matrix BLAS_zuscr_variable_block_begin | ( | int | Mb,
|  | int | Nb,
|  | const int * | K,
|  | const int * | L
| ) |  |

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.

## blas_zuscr_variable_block_begin_()

void blas_zuscr_variable_block_begin_ | ( | int * | Mb,
|  | int * | Nb,
|  | const int * | K,
|  | const int * | L,
|  | blas_sparse_matrix * | A,
|  | int * | 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.
  A | A valid pointer to an empty matrix handle.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.
  Will assign a valid matrix handle to in case of success, or set it to -1 on error.

## BLAS_zusdot()

int BLAS_zusdot | ( | const enum blas_conj_type | conj,
|  | const int | nnz,
|  | const void * | x,
|  | const int * | indx,
|  | const void * | y,
|  | const int | incy,
|  | void * | r,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_zusdot_()

void blas_zusdot_ | ( | const enum blas_conj_type * | conj,
|  | const int * | nnz,
|  | const void * | x,
|  | const int * | indx,
|  | const void * | y,
|  | const int * | incy,
|  | void * | r,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse dot product.

Parameters

  r | Sparse dot result array.
  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements.
  conj | If blas_conj, values of X will be considered conjugated.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_zusga()

int BLAS_zusga | ( | const int | nnz,
|  | const void * | y,
|  | const int | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_zusga_()

void blas_zusga_ | ( | const int * | nnz,
|  | const void * | y,
|  | const int * | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_zusget_diag()

int BLAS_zusget_diag | ( | blas_sparse_matrix | A,
|  | void * | d
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_diag_()

void blas_zusget_diag_ | ( | blas_sparse_matrix * | A,
|  | void * | d,
|  | int * | istat
| ) |  |

Get matrix diagonal. .

Parameters

  A | A valid matrix handle.
  d | Array for the diagonal entries.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusget_element()

int BLAS_zusget_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | void * | v
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_element_()

void blas_zusget_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | void * | v,
|  | int * | istat
| ) |  |

Get a single matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusget_infinity_norm()

int BLAS_zusget_infinity_norm | ( | blas_sparse_matrix | A,
|  | void * | in,
|  | const enum blas_trans_type | trans
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_infinity_norm_()

void blas_zusget_infinity_norm_ | ( | blas_sparse_matrix * | A,
|  | void * | in,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Get infinity norm of matrix.

Parameters

  A | A valid matrix handle.
  in | Infinity norm pointer.
  trans | Transposition parameter.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusget_matrix_nnz()

int BLAS_zusget_matrix_nnz | ( | blas_sparse_matrix | A,
|  | int * | nnz
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_matrix_nnz_()

void blas_zusget_matrix_nnz_ | ( | blas_sparse_matrix * | A,
|  | int * | nnz,
|  | int * | istat
| ) |  |

Get nnz count of matrix.

Parameters

  A | A valid matrix handle.
  nnz | Output value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusget_rows_nnz()

int BLAS_zusget_rows_nnz | ( | blas_sparse_matrix | A,
|  | const int | fr,
|  | const int | lr,
|  | int * | nnzp
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_rows_nnz_()

void blas_zusget_rows_nnz_ | ( | blas_sparse_matrix * | A,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | nnzp,
|  | int * | istat
| ) |  |

Get nnz count of matrix row interval.

Parameters

  A | A valid matrix handle.
  fr | First row.
  lr | Last row.
  nnzp | Pointer to the nonzeroes variable.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusget_rows_sparse()

int BLAS_zusget_rows_sparse | ( | blas_sparse_matrix | A,
|  | void * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int | fr,
|  | const int | lr
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusget_rows_sparse_()

void blas_zusget_rows_sparse_ | ( | blas_sparse_matrix * | A,
|  | void * | VA,
|  | int * | IA,
|  | int * | JA,
|  | int * | nnz,
|  | const int * | fr,
|  | const int * | lr,
|  | int * | istat
| ) |  |

Get sparse rows of matrix.

Parameters

  A | A valid matrix handle.
  VA | pointer to values.
  IA | Row indices array.
  JA | Column indices array.
  nnz | Obtained nonzeroes.
  fr | first row.
  lr | Last row.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusgz()

int BLAS_zusgz | ( | const int | nnz,
|  | void * | y,
|  | const int | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_zusgz_()

void blas_zusgz_ | ( | const int * | nnz,
|  | void * | y,
|  | const int * | incy,
|  | void * | x,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse gather and zero. .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_zusmm()

int BLAS_zusmm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transA,
|  | const int | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix | A,
|  | const void * | b,
|  | const int | ldb,
|  | void * | c,
|  | const int | ldc
| ) |  |

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.

## blas_zusmm_()

void blas_zusmm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transA,
|  | const int * | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const void * | b,
|  | const int * | ldb,
|  | void * | c,
|  | const int * | ldc,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusmv()

int BLAS_zusmv | ( | const enum blas_trans_type | transA,
|  | const void * | alpha,
|  | const blas_sparse_matrix | A,
|  | const void * | x,
|  | const int | incx,
|  | void * | y,
|  | const int | incy
| ) |  |

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.

## blas_zusmv_()

void blas_zusmv_ | ( | const enum blas_trans_type * | transA,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | A,
|  | const void * | x,
|  | const int * | incx,
|  | void * | y,
|  | const int * | incy,
|  | int * | 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).

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusrows_scale()

int BLAS_zusrows_scale | ( | blas_sparse_matrix | A,
|  | const void * | d,
|  | const enum blas_trans_type | trans
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusrows_scale_()

void blas_zusrows_scale_ | ( | blas_sparse_matrix * | A,
|  | const void * | d,
|  | const enum blas_trans_type * | trans,
|  | int * | istat
| ) |  |

Scale rows interval of matrix by specified factor.

Parameters

  A | A valid matrix handle.
  d | Rows scaling vector.
  trans | Transposition parameter (if transposed will scale columns).

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zussc()

int BLAS_zussc | ( | const int | nnz,
|  | const void * | x,
|  | void * | y,
|  | const int | incy,
|  | const int * | indx,
|  | const enum blas_base_type | index_base
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..

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

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## blas_zussc_()

void blas_zussc_ | ( | const int * | nnz,
|  | const void * | x,
|  | void * | y,
|  | const int * | incy,
|  | const int * | indx,
|  | const enum blas_base_type * | index_base,
|  | int * | istat
| ) |  |

Sparse scatter: .

Parameters

  y | Array for vector.
  x | Array for vector.
  nnz | Size of and vectors.
  indx | Is the array of indices at which sparse vector will be accessed.
  index_base | Specifies the contents of `indx`, either blas_one_base or blas_one_base.
  incy | The distance between consecutive `y` array elements..
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

Warning
  Sparse BLAS Level 1 has been implemented, although not with performance in mind.

## BLAS_zusset_element()

int BLAS_zusset_element | ( | blas_sparse_matrix | A,
|  | const int | i,
|  | const int | j,
|  | void * | v
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

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

## blas_zusset_element_()

void blas_zusset_element_ | ( | blas_sparse_matrix * | A,
|  | const int * | i,
|  | const int * | j,
|  | void * | v,
|  | int * | istat
| ) |  |

Set a single (existing) matrix nonzero coefficient .

Parameters

  A | A valid matrix handle.
  i | Row index.
  j | Column index.
  v | Value pointer.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zusset_elements()

int BLAS_zusset_elements | ( | blas_sparse_matrix | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const void * | va,
|  | const int | nnz
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

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

## blas_zusset_elements_()

void blas_zusset_elements_ | ( | blas_sparse_matrix * | A,
|  | const int * | ia,
|  | const int * | ja,
|  | const void * | va,
|  | const int * | nnz,
|  | int * | istat
| ) |  |

Set individual matrix nonzero coefficients values. The operation is pattern preserving, that is, nonzeroes must already exist.

Parameters

  A | A valid matrix handle.
  ia | Row indices array.
  ja | Column indices array.
  va | Values array.
  nnz | Length of the `ia`,ja,va arrays.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality..

Parameters

  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zussm()

int BLAS_zussm | ( | const enum blas_order_type | order,
|  | const enum blas_trans_type | transT,
|  | const int | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix | T,
|  | void * | b,
|  | const int | ldb
| ) |  |

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.

## blas_zussm_()

void blas_zussm_ | ( | const enum blas_order_type * | order,
|  | const enum blas_trans_type * | transT,
|  | const int * | nrhs,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | T,
|  | void * | b,
|  | const int * | ldb,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## BLAS_zussv()

int BLAS_zussv | ( | enum blas_trans_type | transT,
|  | const void * | alpha,
|  | const blas_sparse_matrix | T,
|  | void * | x,
|  | const int | incx
| ) |  |

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.

## blas_zussv_()

void blas_zussv_ | ( | enum blas_trans_type * | transT,
|  | const void * | alpha,
|  | const blas_sparse_matrix * | T,
|  | void * | x,
|  | const int * | incx,
|  | int * | 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.
  istat | If non `NULL`, `*istat` will be set to the return code, either 0 (success) or -1 (failure).

Returns
  This is a subroutine for Fortran, so it does not return any value.

## rsb_blas_file_mtx_load()

blas_sparse_matrix rsb_blas_file_mtx_load | ( | const rsb_char_t * | filename,
|  | rsb_type_t | typecode
| ) |  |

Load Matrix Market matrix file of specified type to a matrix, and return Sparse BLAS handler.

Parameters

  filename | The specified matrix file name (cannot be `NULL`).
  typecode | A valid type code for the desired output matrix (see matrix_type_symbols_section).

Returns
  On success, a valid matrix handle will be returned. On error, blas_invalid_handle will be returned.

## rsb_blas_get_mtx()

struct rsb_mtx_t * rsb_blas_get_mtx | ( | blas_sparse_matrix | A | ) |

Given a valid Sparse BLAS handle, returns a pointer to the inner rsb_mtx_t structure. Then, this can be used for many of the rsb.h functions. This is an experimental function, so we recommend to use it with functions not modifying the matrix (ones that take `const` `struct` `rsb_mtx_t*mtxAp`). You can use this function from either Fortran or C.

Parameters

  A | A valid matrix handle.

Returns
  On success, a valid pointer to the inner matrix structure (`struct` `rsb_mtx_t*`); on error, `NULL`.

An example using Fortran:

...
USE blas_sparse
USE rsb
IMPLICIT NONE
TYPE(C_PTR),TARGET :: mtxAp = C_NULL_PTR ! matrix pointer
INTEGER :: A ! blas_sparse_matrix handle
INTEGER, TARGET :: istat = 0
... ! begin, populate and finalize A, e.g. using BLAS_duscr_begin, BLAS_duscr_insert_entries, BLAS_uscr_end
! get pointer to rsb structure:
mtxAp = rsb_blas_get_mtx(A)
! Now one can use it with any rsb.h/rsb.F90 function, e.g.:
istat = rsb_file_mtx_save(mtxAp, C_NULL_PTR) ! write to stdout
blas_sparse_matrix
int blas_sparse_matrix
Definition blas_sparse.h:167
rsb_file_mtx_save
rsb_err_t rsb_file_mtx_save(const struct rsb_mtx_t *mtxAp, const rsb_char_t *filename)
Definition rsb_rsb.c:948
BLAS_uscr_end
int BLAS_uscr_end(blas_sparse_matrix A)
Definition rsb_libspblas.c:2618
rsb_blas_get_mtx
struct rsb_mtx_t * rsb_blas_get_mtx(blas_sparse_matrix A)
Definition rsb_libspblas.c:3688
BLAS_duscr_begin
blas_sparse_matrix BLAS_duscr_begin(int m, int n)
Definition rsb_libspblas.c:1472
BLAS_duscr_insert_entries
int BLAS_duscr_insert_entries(blas_sparse_matrix A, int nnz, const double *val, const int *indx, const int *jndx)
Definition rsb_libspblas.c:2090
blas_sparse
Definition rsb_blas_sparse.F90:29
rsb
Definition rsb.F90:11

See also
  rsb_mtx_get_coo, rsb_mtx_get_csr, rsb_mtx_get_rows_sparse, rsb_mtx_get_coo_block, rsb_mtx_get_prec, rsb_mtx_get_nrm, rsb_mtx_get_vec, rsb_file_mtx_get_dims, rsb_mtx_get_vals,
  rsb_mtx_upd_vals, rsb_mtx_set_vals,
  rsb_spmsp_to_dense, rsb_sppsp, rsb_spmsp, rsb_mtx_add_to_dense,
  rsb_mtx_rndr, rsb_file_mtx_rndr,
  rsb_mtx_get_info, rsb_mtx_get_info_str, rsb_file_mtx_save, rsb_file_vec_load, rsb_file_mtx_load.

Note
  This function is an extension implemented by `librsb` and thus it is not part of the standard. Do not rely on it, as it may change! Please contact the library maintainers if you need its functionality.