NAME

       librsb - rsb-spblas.h - 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.

DESCRIPTION

SYNOPSIS

   Functions
       int BLAS_susdot (enum blas_conj_type conj, int nnz, const float *x, const int *indx, const float *y, int
           incy, float *r, enum blas_base_type index_base)
       void blas_susdot_ (enum blas_conj_type *conj, int *nnz, const float *x, const int *indx, const float *y,
           int *incy, float *r, enum blas_base_type *index_base, int *istat)
       int BLAS_dusdot (enum blas_conj_type conj, int nnz, const double *x, const int *indx, const double *y,
           int incy, double *r, enum blas_base_type index_base)
       void blas_dusdot_ (enum blas_conj_type *conj, int *nnz, const double *x, const int *indx, const double
           *y, int *incy, double *r, enum blas_base_type *index_base, int *istat)
       int BLAS_cusdot (enum blas_conj_type conj, int nnz, const void *x, const int *indx, const void *y, int
           incy, void *r, enum blas_base_type index_base)
       void blas_cusdot_ (enum blas_conj_type *conj, int *nnz, const void *x, const int *indx, const void *y,
           int *incy, void *r, enum blas_base_type *index_base, int *istat)
       int BLAS_zusdot (enum blas_conj_type conj, int nnz, const void *x, const int *indx, const void *y, int
           incy, void *r, enum blas_base_type index_base)
       void blas_zusdot_ (enum blas_conj_type *conj, int *nnz, const void *x, const int *indx, const void *y,
           int *incy, void *r, enum blas_base_type *index_base, int *istat)
       int BLAS_susaxpy (int nnz, float alpha, const float *x, const int *indx, float *y, int incy, enum
           blas_base_type index_base)
       void blas_susaxpy_ (int *nnz, float *alpha, const float *x, const int *indx, float *y, int *incy, enum
           blas_base_type *index_base, int *istat)
       int BLAS_dusaxpy (int nnz, double alpha, const double *x, const int *indx, double *y, int incy, enum
           blas_base_type index_base)
       void blas_dusaxpy_ (int *nnz, double *alpha, const double *x, const int *indx, double *y, int *incy, enum
           blas_base_type *index_base, int *istat)
       int BLAS_cusaxpy (int nnz, const void *alpha, const void *x, const int *indx, void *y, int incy, enum
           blas_base_type index_base)
       void blas_cusaxpy_ (int *nnz, const void *alpha, const void *x, const int *indx, void *y, int *incy, enum
           blas_base_type *index_base, int *istat)
       int BLAS_zusaxpy (int nnz, const void *alpha, const void *x, const int *indx, void *y, int incy, enum
           blas_base_type index_base)
       void blas_zusaxpy_ (int *nnz, const void *alpha, const void *x, const int *indx, void *y, int *incy, enum
           blas_base_type *index_base, int *istat)
       int BLAS_susga (int nnz, const float *y, int incy, float *x, const int *indx, enum blas_base_type
           index_base)
       void blas_susga_ (int *nnz, const float *y, int *incy, float *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_dusga (int nnz, const double *y, int incy, double *x, const int *indx, enum blas_base_type
           index_base)
       void blas_dusga_ (int *nnz, const double *y, int *incy, double *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_cusga (int nnz, const void *y, int incy, void *x, const int *indx, enum blas_base_type
           index_base)
       void blas_cusga_ (int *nnz, const void *y, int *incy, void *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_zusga (int nnz, const void *y, int incy, void *x, const int *indx, enum blas_base_type
           index_base)
       void blas_zusga_ (int *nnz, const void *y, int *incy, void *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_susgz (int nnz, float *y, int incy, float *x, const int *indx, enum blas_base_type index_base)
       void blas_susgz_ (int *nnz, float *y, int *incy, float *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_dusgz (int nnz, double *y, int incy, double *x, const int *indx, enum blas_base_type index_base)
       void blas_dusgz_ (int *nnz, double *y, int *incy, double *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_cusgz (int nnz, void *y, int incy, void *x, const int *indx, enum blas_base_type index_base)
       void blas_cusgz_ (int *nnz, void *y, int *incy, void *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_zusgz (int nnz, void *y, int incy, void *x, const int *indx, enum blas_base_type index_base)
       void blas_zusgz_ (int *nnz, void *y, int *incy, void *x, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_sussc (int nnz, const float *x, float *y, int incy, const int *indx, enum blas_base_type
           index_base)
       void blas_sussc_ (int *nnz, const float *x, float *y, int *incy, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_dussc (int nnz, const double *x, double *y, int incy, const int *indx, enum blas_base_type
           index_base)
       void blas_dussc_ (int *nnz, const double *x, double *y, int *incy, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_cussc (int nnz, const void *x, void *y, int incy, const int *indx, enum blas_base_type
           index_base)
       void blas_cussc_ (int *nnz, const void *x, void *y, int *incy, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_zussc (int nnz, const void *x, void *y, int incy, const int *indx, enum blas_base_type
           index_base)
       void blas_zussc_ (int *nnz, const void *x, void *y, int *incy, const int *indx, enum blas_base_type
           *index_base, int *istat)
       int BLAS_susmv (enum blas_trans_type transA, float alpha, blas_sparse_matrix A, const float *x, int incx,
           float *y, int incy)
       void blas_susmv_ (enum blas_trans_type *transA, float *alpha, blas_sparse_matrix *A, const float *x, int
           *incx, float *y, int *incy, int *istat)
       int BLAS_dusmv (enum blas_trans_type transA, double alpha, blas_sparse_matrix A, const double *x, int
           incx, double *y, int incy)
       void blas_dusmv_ (enum blas_trans_type *transA, double *alpha, blas_sparse_matrix *A, const double *x,
           int *incx, double *y, int *incy, int *istat)
       int BLAS_cusmv (enum blas_trans_type transA, const void *alpha, blas_sparse_matrix A, const void *x, int
           incx, void *y, int incy)
       void blas_cusmv_ (enum blas_trans_type *transA, const void *alpha, blas_sparse_matrix *A, const void *x,
           int *incx, void *y, int *incy, int *istat)
       int BLAS_zusmv (enum blas_trans_type transA, const void *alpha, blas_sparse_matrix A, const void *x, int
           incx, void *y, int incy)
       void blas_zusmv_ (enum blas_trans_type *transA, const void *alpha, blas_sparse_matrix *A, const void *x,
           int *incx, void *y, int *incy, int *istat)
       int BLAS_sussv (enum blas_trans_type transT, float alpha, blas_sparse_matrix T, float *x, int incx)
       void blas_sussv_ (enum blas_trans_type *transT, float *alpha, blas_sparse_matrix *T, float *x, int *incx,
           int *istat)
       int BLAS_dussv (enum blas_trans_type transT, double alpha, blas_sparse_matrix T, double *x, int incx)
       void blas_dussv_ (enum blas_trans_type *transT, double *alpha, blas_sparse_matrix *T, double *x, int
           *incx, int *istat)
       int BLAS_cussv (enum blas_trans_type transT, const void *alpha, blas_sparse_matrix T, void *x, int incx)
       void blas_cussv_ (enum blas_trans_type *transT, const void *alpha, blas_sparse_matrix *T, void *x, int
           *incx, int *istat)
       int BLAS_zussv (enum blas_trans_type transT, const void *alpha, blas_sparse_matrix T, void *x, int incx)
       void blas_zussv_ (enum blas_trans_type *transT, const void *alpha, blas_sparse_matrix *T, void *x, int
           *incx, int *istat)
       int BLAS_susmm (enum blas_order_type order, enum blas_trans_type transA, int nrhs, float alpha,
           blas_sparse_matrix A, const float *b, int ldb, float *c, int ldc)
       void blas_susmm_ (enum blas_order_type *order, enum blas_trans_type *transA, int *nrhs, float *alpha,
           blas_sparse_matrix *A, const float *b, int *ldb, float *c, int *ldc, int *istat)
       int BLAS_dusmm (enum blas_order_type order, enum blas_trans_type transA, int nrhs, double alpha,
           blas_sparse_matrix A, const double *b, int ldb, double *c, int ldc)
       void blas_dusmm_ (enum blas_order_type *order, enum blas_trans_type *transA, int *nrhs, double *alpha,
           blas_sparse_matrix *A, const double *b, int *ldb, double *c, int *ldc, int *istat)
       int BLAS_cusmm (enum blas_order_type order, enum blas_trans_type transA, int nrhs, const void *alpha,
           blas_sparse_matrix A, const void *b, int ldb, void *c, int ldc)
       void blas_cusmm_ (enum blas_order_type *order, enum blas_trans_type *transA, int *nrhs, const void
           *alpha, blas_sparse_matrix *A, const void *b, int *ldb, void *c, int *ldc, int *istat)
       int BLAS_zusmm (enum blas_order_type order, enum blas_trans_type transA, int nrhs, const void *alpha,
           blas_sparse_matrix A, const void *b, int ldb, void *c, int ldc)
       void blas_zusmm_ (enum blas_order_type *order, enum blas_trans_type *transA, int *nrhs, const void
           *alpha, blas_sparse_matrix *A, const void *b, int *ldb, void *c, int *ldc, int *istat)
       int BLAS_sussm (enum blas_order_type order, enum blas_trans_type transT, int nrhs, float alpha,
           blas_sparse_matrix T, float *b, int ldb)
       void blas_sussm_ (enum blas_order_type *order, enum blas_trans_type *transT, int *nrhs, float *alpha,
           blas_sparse_matrix *T, float *b, int *ldb, int *istat)
       int BLAS_dussm (enum blas_order_type order, enum blas_trans_type transT, int nrhs, double alpha,
           blas_sparse_matrix T, double *b, int ldb)
       void blas_dussm_ (enum blas_order_type *order, enum blas_trans_type *transT, int *nrhs, double *alpha,
           blas_sparse_matrix *T, double *b, int *ldb, int *istat)
       int BLAS_cussm (enum blas_order_type order, enum blas_trans_type transT, int nrhs, const void *alpha,
           blas_sparse_matrix T, void *b, int ldb)
       void blas_cussm_ (enum blas_order_type *order, enum blas_trans_type *transT, int *nrhs, const void
           *alpha, blas_sparse_matrix *T, void *b, int *ldb, int *istat)
       int BLAS_zussm (enum blas_order_type order, enum blas_trans_type transT, int nrhs, const void *alpha,
           blas_sparse_matrix T, void *b, int ldb)
       void blas_zussm_ (enum blas_order_type *order, enum blas_trans_type *transT, int *nrhs, const void
           *alpha, blas_sparse_matrix *T, void *b, 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, enum blas_trans_type trans)
       void blas_susrows_scale_ (blas_sparse_matrix *A, const float *d, enum blas_trans_type *trans, int *istat)
       int BLAS_dusrows_scale (blas_sparse_matrix A, const double *d, enum blas_trans_type trans)
       void blas_dusrows_scale_ (blas_sparse_matrix *A, const double *d, enum blas_trans_type *trans, int
           *istat)
       int BLAS_cusrows_scale (blas_sparse_matrix A, const void *d, enum blas_trans_type trans)
       void blas_cusrows_scale_ (blas_sparse_matrix *A, const void *d, enum blas_trans_type *trans, int *istat)
       int BLAS_zusrows_scale (blas_sparse_matrix A, const void *d, enum blas_trans_type trans)
       void blas_zusrows_scale_ (blas_sparse_matrix *A, const void *d, 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, int fr, int lr, int *nnzp)
       void blas_susget_rows_nnz_ (blas_sparse_matrix *A, int *fr, int *lr, int *nnzp, int *istat)
       int BLAS_dusget_rows_nnz (blas_sparse_matrix A, int fr, int lr, int *nnzp)
       void blas_dusget_rows_nnz_ (blas_sparse_matrix *A, int *fr, int *lr, int *nnzp, int *istat)
       int BLAS_cusget_rows_nnz (blas_sparse_matrix A, int fr, int lr, int *nnzp)
       void blas_cusget_rows_nnz_ (blas_sparse_matrix *A, int *fr, int *lr, int *nnzp, int *istat)
       int BLAS_zusget_rows_nnz (blas_sparse_matrix A, int fr, int lr, int *nnzp)
       void blas_zusget_rows_nnz_ (blas_sparse_matrix *A, int *fr, int *lr, int *nnzp, int *istat)
       int BLAS_susget_rows_sparse (blas_sparse_matrix A, float *VA, int *IA, int *JA, int *nnz, int fr, int lr)
       void blas_susget_rows_sparse_ (blas_sparse_matrix *A, float *VA, int *IA, int *JA, int *nnz, int *fr, int
           *lr, int *istat)
       int BLAS_dusget_rows_sparse (blas_sparse_matrix A, double *VA, int *IA, int *JA, int *nnz, int fr, int
           lr)
       void blas_dusget_rows_sparse_ (blas_sparse_matrix *A, double *VA, int *IA, int *JA, int *nnz, int *fr,
           int *lr, int *istat)
       int BLAS_cusget_rows_sparse (blas_sparse_matrix A, void *VA, int *IA, int *JA, int *nnz, int fr, int lr)
       void blas_cusget_rows_sparse_ (blas_sparse_matrix *A, void *VA, int *IA, int *JA, int *nnz, int *fr, int
           *lr, int *istat)
       int BLAS_zusget_rows_sparse (blas_sparse_matrix A, void *VA, int *IA, int *JA, int *nnz, int fr, int lr)
       void blas_zusget_rows_sparse_ (blas_sparse_matrix *A, void *VA, int *IA, int *JA, int *nnz, int *fr, 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, enum blas_trans_type trans)
       void blas_susget_infinity_norm_ (blas_sparse_matrix *A, float *in, enum blas_trans_type *trans, int
           *istat)
       int BLAS_dusget_infinity_norm (blas_sparse_matrix A, double *in, enum blas_trans_type trans)
       void blas_dusget_infinity_norm_ (blas_sparse_matrix *A, double *in, enum blas_trans_type *trans, int
           *istat)
       int BLAS_cusget_infinity_norm (blas_sparse_matrix A, void *in, enum blas_trans_type trans)
       void blas_cusget_infinity_norm_ (blas_sparse_matrix *A, void *in, enum blas_trans_type *trans, int
           *istat)
       int BLAS_zusget_infinity_norm (blas_sparse_matrix A, void *in, enum blas_trans_type trans)
       void blas_zusget_infinity_norm_ (blas_sparse_matrix *A, void *in, enum blas_trans_type *trans, int
           *istat)
       int BLAS_susset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const float *va, int nnz)
       void blas_susset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const float *va, int
           *nnz, int *istat)
       int BLAS_dusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const double *va, int nnz)
       void blas_dusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const double *va, int
           *nnz, int *istat)
       int BLAS_cusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const void *va, int nnz)
       void blas_cusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const void *va, int
           *nnz, int *istat)
       int BLAS_zusset_elements (blas_sparse_matrix A, const int *ia, const int *ja, const void *va, int nnz)
       void blas_zusset_elements_ (blas_sparse_matrix *A, const int *ia, const int *ja, const void *va, int
           *nnz, int *istat)
       int BLAS_susset_element (blas_sparse_matrix A, int i, int j, float *v)
       void blas_susset_element_ (blas_sparse_matrix *A, int *i, int *j, float *v, int *istat)
       int BLAS_dusset_element (blas_sparse_matrix A, int i, int j, double *v)
       void blas_dusset_element_ (blas_sparse_matrix *A, int *i, int *j, double *v, int *istat)
       int BLAS_cusset_element (blas_sparse_matrix A, int i, int j, void *v)
       void blas_cusset_element_ (blas_sparse_matrix *A, int *i, int *j, void *v, int *istat)
       int BLAS_zusset_element (blas_sparse_matrix A, int i, int j, void *v)
       void blas_zusset_element_ (blas_sparse_matrix *A, int *i, int *j, void *v, int *istat)
       int BLAS_susget_element (blas_sparse_matrix A, int i, int j, float *v)
       void blas_susget_element_ (blas_sparse_matrix *A, int *i, int *j, float *v, int *istat)
       int BLAS_dusget_element (blas_sparse_matrix A, int i, int j, double *v)
       void blas_dusget_element_ (blas_sparse_matrix *A, int *i, int *j, double *v, int *istat)
       int BLAS_cusget_element (blas_sparse_matrix A, int i, int j, void *v)
       void blas_cusget_element_ (blas_sparse_matrix *A, int *i, int *j, void *v, int *istat)
       int BLAS_zusget_element (blas_sparse_matrix A, int i, int j, void *v)
       void blas_zusget_element_ (blas_sparse_matrix *A, int *i, int *j, void *v, int *istat)
       int BLAS_usgp (blas_sparse_matrix A, int pname)
       void blas_usgp_ (blas_sparse_matrix *A, int *pname, int *istat)
       void blas_ussp_ (blas_sparse_matrix *A, int *pname, int *istat)
       int BLAS_ussp (blas_sparse_matrix A, int pname)
       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  we  list  functions for both Fortran and C functions. However, the Fortran functions are declared
         and documented with the C notation. We may provide a better documentation in a subsequent 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 will 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)

Function Documentation

   int BLAS_cusaxpy (int nnz, const void * alpha, const void * x, const int * indx, void *  y,  int  incy,  enum
       blas_base_type index_base)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
       Returns:
           On success, 0 is returned; on error, -1.
       Warning:
           Sparse BLAS Level 1 has been implemented and is working, although not with performance in mind.
   void  blas_cusaxpy_  (int  * nnz, const void * alpha, const void * x, const int * indx, void * y, int * incy,
       enum blas_base_type * index_base, int * istat)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
           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 and is working, although not with performance in mind.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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_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.
   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 $A$ in case of success, or set it to -1 on error.
   int BLAS_cusdot (enum blas_conj_type conj, int nnz, const void * x, const int * indx, const  void  *  y,  int
       incy, void * r, enum blas_base_type index_base)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_cusdot_  (enum blas_conj_type * conj, int * nnz, const void * x, const int * indx, const void * y,
       int * incy, void * r, enum blas_base_type * index_base, int * istat)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_cusga (int nnz, const void * y,  int  incy,  void  *  x,  const  int  *  indx,  enum  blas_base_type
       index_base)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_cusga_  (int  * nnz, const void * y, int * incy, void * x, const int * indx, enum blas_base_type *
       index_base, int * istat)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_cusget_diag (blas_sparse_matrix A, void * d)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   void blas_cusget_diag_ (blas_sparse_matrix * A, void * d, int * istat)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   int BLAS_cusget_element (blas_sparse_matrix A, int i, int j, void * v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_cusget_element_ (blas_sparse_matrix * A, int * i, int * j, void * v, int * istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_cusget_infinity_norm (blas_sparse_matrix A, void * in, 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.
   void  blas_cusget_infinity_norm_  (blas_sparse_matrix  *  A,  void  * in, 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.
   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.
   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.
   int BLAS_cusget_rows_nnz (blas_sparse_matrix A, int fr, 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.
   void blas_cusget_rows_nnz_ (blas_sparse_matrix * A, int * fr, 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.
   int BLAS_cusget_rows_sparse (blas_sparse_matrix A, void * VA, int * IA, int * JA, int * nnz, int fr, 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.
   void blas_cusget_rows_sparse_ (blas_sparse_matrix * A, void * VA, int * IA, int * JA, int * nnz,  int  *  fr,
       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.
   int BLAS_cusgz (int nnz, void * y, int incy, void * x, const int * indx, enum blas_base_type index_base)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_cusgz_ (int * nnz, void * y, int * incy, void  *  x,  const  int  *  indx,  enum  blas_base_type  *
       index_base, int * istat)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int  BLAS_cusmm  (enum  blas_order_type  order,  enum  blas_trans_type  transA, int nrhs, const void * alpha,
       blas_sparse_matrix A, const void * b, int ldb, void * c, int ldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_cusmm_ (enum blas_order_type * order, enum blas_trans_type * transA,  int  *  nrhs,  const  void  *
       alpha, blas_sparse_matrix * A, const void * b, int * ldb, void * c, int * ldc, int * istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int  BLAS_cusmv  (enum  blas_trans_type transA, const void * alpha, blas_sparse_matrix A, const void * x, int
       incx, void * y, int incy)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_cusmv_ (enum blas_trans_type * transA, const void * alpha, blas_sparse_matrix * A, const void *  x,
       int * incx, void * y, int * incy, int * istat)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int BLAS_cusrows_scale (blas_sparse_matrix A, const void * d, 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.
   void blas_cusrows_scale_ (blas_sparse_matrix * A, const void * d, 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.
   int  BLAS_cussc  (int  nnz,  const  void  *  x,  void  *  y,  int incy, const int * indx, enum blas_base_type
       index_base)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_cussc_ (int * nnz, const void * x, void * y, int * incy, const int * indx,  enum  blas_base_type  *
       index_base, int * istat)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_cusset_element (blas_sparse_matrix A, int i, int j, void * v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_cusset_element_ (blas_sparse_matrix * A, int * i, int * j, void * v, int * istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_cusset_elements (blas_sparse_matrix A, const int * ia, const int * ja, const void * va, 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.
   void  blas_cusset_elements_  (blas_sparse_matrix  * A, const int * ia, const int * ja, const void * va, 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.
   int BLAS_cussm (enum blas_order_type order, enum blas_trans_type  transT,  int  nrhs,  const  void  *  alpha,
       blas_sparse_matrix T, void * b, int ldb)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_cussm_ (enum blas_order_type * order, enum blas_trans_type * transT,  int  *  nrhs,  const  void  *
       alpha, blas_sparse_matrix * T, void * b, int * ldb, int * istat)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
           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.
   int BLAS_cussv (enum blas_trans_type transT, const void * alpha, blas_sparse_matrix T, void * x, int incx)
       Triangular solve, by a dense vector. Either of  $X  \leftarrow  \alpha  T^{-1}X,$  $X  \leftarrow  \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_cussv_ (enum blas_trans_type * transT, const void * alpha, blas_sparse_matrix * T, void * x, int *
       incx, int * istat)
       Triangular solve, by a dense vector. Either of  $X  \leftarrow  \alpha  T^{-1}X,$  $X  \leftarrow  \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
           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.
   int  BLAS_dusaxpy  (int  nnz,  double  alpha,  const double * x, const int * indx, double * y, int incy, enum
       blas_base_type index_base)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
       Returns:
           On success, 0 is returned; on error, -1.
       Warning:
           Sparse BLAS Level 1 has been implemented and is working, although not with performance in mind.
   void blas_dusaxpy_ (int * nnz, double * alpha, const double * x, const int * indx, double * y,  int  *  incy,
       enum blas_base_type * index_base, int * istat)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
           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 and is working, although not with performance in mind.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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_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.
   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 $A$ in case of success, or set it to -1 on error.
   int BLAS_dusdot (enum blas_conj_type conj, int nnz, const double * x, const int * indx, const double * y, int
       incy, double * r, enum blas_base_type index_base)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_dusdot_ (enum blas_conj_type * conj, int * nnz, const double * x, const int * indx, const double  *
       y, int * incy, double * r, enum blas_base_type * index_base, int * istat)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int  BLAS_dusga  (int  nnz,  const  double  *  y, int incy, double * x, const int * indx, enum blas_base_type
       index_base)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_dusga_ (int * nnz, const double * y, int * incy, double * x, const int * indx, enum  blas_base_type
       * index_base, int * istat)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_dusget_diag (blas_sparse_matrix A, double * d)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   void blas_dusget_diag_ (blas_sparse_matrix * A, double * d, int * istat)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   int BLAS_dusget_element (blas_sparse_matrix A, int i, int j, double * v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_dusget_element_ (blas_sparse_matrix * A, int * i, int * j, double * v, int * istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_dusget_infinity_norm (blas_sparse_matrix A, double * in, 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.
   void blas_dusget_infinity_norm_ (blas_sparse_matrix * A, double * in, 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.
   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.
   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.
   int BLAS_dusget_rows_nnz (blas_sparse_matrix A, int fr, 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.
   void blas_dusget_rows_nnz_ (blas_sparse_matrix * A, int * fr, 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.
   int BLAS_dusget_rows_sparse (blas_sparse_matrix A, double * VA, int * IA, int * JA, int * nnz,  int  fr,  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.
   void blas_dusget_rows_sparse_ (blas_sparse_matrix * A, double * VA, int * IA, int * JA, int * nnz, int *  fr,
       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.
   int BLAS_dusgz (int nnz, double * y, int incy, double * x, const int * indx, enum blas_base_type index_base)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_dusgz_ (int * nnz, double * y, int * incy, double * x, const int  *  indx,  enum  blas_base_type  *
       index_base, int * istat)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int   BLAS_dusmm   (enum  blas_order_type  order,  enum  blas_trans_type  transA,  int  nrhs,  double  alpha,
       blas_sparse_matrix A, const double * b, int ldb, double * c, int ldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_dusmm_ (enum blas_order_type * order, enum blas_trans_type * transA, int * nrhs,  double  *  alpha,
       blas_sparse_matrix * A, const double * b, int * ldb, double * c, int * ldc, int * istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int  BLAS_dusmv (enum blas_trans_type transA, double alpha, blas_sparse_matrix A, const double * x, int incx,
       double * y, int incy)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_dusmv_ (enum blas_trans_type * transA, double * alpha, blas_sparse_matrix * A, const  double  *  x,
       int * incx, double * y, int * incy, int * istat)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int BLAS_dusrows_scale (blas_sparse_matrix A, const double * d, 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.
   void blas_dusrows_scale_ (blas_sparse_matrix * A, const double * d,  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.
   int BLAS_dussc (int nnz, const double * x, double * y, int  incy,  const  int  *  indx,  enum  blas_base_type
       index_base)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_dussc_ (int * nnz, const double * x, double * y, int * incy, const int * indx, enum blas_base_type
       * index_base, int * istat)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_dusset_element (blas_sparse_matrix A, int i, int j, double * v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_dusset_element_ (blas_sparse_matrix * A, int * i, int * j, double * v, int * istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_dusset_elements (blas_sparse_matrix A, const int * ia, const int * ja, const double * va, 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.
   void blas_dusset_elements_ (blas_sparse_matrix * A, const int * ia, const int * ja, const double * va, 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.
   int   BLAS_dussm   (enum  blas_order_type  order,  enum  blas_trans_type  transT,  int  nrhs,  double  alpha,
       blas_sparse_matrix T, double * b, int ldb)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B  \leftarrow  \alpha  T^{-1}  B,$  $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_dussm_  (enum  blas_order_type * order, enum blas_trans_type * transT, int * nrhs, double * alpha,
       blas_sparse_matrix * T, double * b, int * ldb, int * istat)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B  \leftarrow  \alpha  T^{-1}  B,$  $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
           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.
   int BLAS_dussv (enum blas_trans_type transT, double alpha, blas_sparse_matrix T, double * x, int incx)
       Triangular  solve,  by  a  dense  vector.  Either  of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_dussv_ (enum blas_trans_type * transT, double * alpha, blas_sparse_matrix * T, double *  x,  int  *
       incx, int * istat)
       Triangular  solve,  by  a  dense  vector.  Either  of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
           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.
   int BLAS_susaxpy (int nnz, float alpha, const float * x, const  int  *  indx,  float  *  y,  int  incy,  enum
       blas_base_type index_base)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
       Returns:
           On success, 0 is returned; on error, -1.
       Warning:
           Sparse BLAS Level 1 has been implemented and is working, although not with performance in mind.
   void  blas_susaxpy_ (int * nnz, float * alpha, const float * x, const int * indx, float * y, int * incy, enum
       blas_base_type * index_base, int * istat)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
           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 and is working, although not with performance in mind.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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_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.
   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 $A$ in case of success, or set it to -1 on error.
   int BLAS_susdot (enum blas_conj_type conj, int nnz, const float * x, const int * indx, const float *  y,  int
       incy, float * r, enum blas_base_type index_base)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_susdot_ (enum blas_conj_type * conj, int * nnz, const float * x, const int * indx, const float * y,
       int * incy, float * r, enum blas_base_type * index_base, int * istat)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int  BLAS_susga  (int  nnz,  const  float  *  y,  int  incy, float * x, const int * indx, enum blas_base_type
       index_base)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_susga_ (int * nnz, const float * y, int * incy, float * x, const int * indx, enum blas_base_type  *
       index_base, int * istat)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_susget_diag (blas_sparse_matrix A, float * d)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   void blas_susget_diag_ (blas_sparse_matrix * A, float * d, int * istat)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   int BLAS_susget_element (blas_sparse_matrix A, int i, int j, float * v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_susget_element_ (blas_sparse_matrix * A, int * i, int * j, float * v, int * istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_susget_infinity_norm (blas_sparse_matrix A, float * in, 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.
   void blas_susget_infinity_norm_ (blas_sparse_matrix * A, float * in, 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.
   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.
   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.
   int BLAS_susget_rows_nnz (blas_sparse_matrix A, int fr, 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.
   void blas_susget_rows_nnz_ (blas_sparse_matrix * A, int * fr, 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.
   int BLAS_susget_rows_sparse (blas_sparse_matrix A, float * VA, int * IA, int * JA, int * nnz, int fr, 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.
   void  blas_susget_rows_sparse_  (blas_sparse_matrix * A, float * VA, int * IA, int * JA, int * nnz, int * fr,
       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.
   int BLAS_susgz (int nnz, float * y, int incy, float * x, const int * indx, enum blas_base_type index_base)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_susgz_  (int  *  nnz,  float  *  y, int * incy, float * x, const int * indx, enum blas_base_type *
       index_base, int * istat)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int  BLAS_susmm  (enum  blas_order_type  order,  enum  blas_trans_type  transA,  int   nrhs,   float   alpha,
       blas_sparse_matrix A, const float * b, int ldb, float * c, int ldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_susmm_  (enum  blas_order_type  * order, enum blas_trans_type * transA, int * nrhs, float * alpha,
       blas_sparse_matrix * A, const float * b, int * ldb, float * c, int * ldc, int * istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int BLAS_susmv (enum blas_trans_type transA, float alpha, blas_sparse_matrix A, const float *  x,  int  incx,
       float * y, int incy)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_susmv_ (enum blas_trans_type * transA, float * alpha, blas_sparse_matrix * A, const float * x, int
       * incx, float * y, int * incy, int * istat)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int BLAS_susrows_scale (blas_sparse_matrix A, const float * d, 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.
   void blas_susrows_scale_ (blas_sparse_matrix * A, const float * d, 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.
   int BLAS_sussc (int nnz, const float * x, float *  y,  int  incy,  const  int  *  indx,  enum  blas_base_type
       index_base)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_sussc_ (int * nnz, const float * x, float * y, int * incy, const int * indx, enum blas_base_type *
       index_base, int * istat)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_susset_element (blas_sparse_matrix A, int i, int j, float * v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_susset_element_ (blas_sparse_matrix * A, int * i, int * j, float * v, int * istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_susset_elements (blas_sparse_matrix A, const int * ia, const int * ja, const float * va, 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.
   void blas_susset_elements_ (blas_sparse_matrix * A, const int * ia, const int * ja, const float * va,  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.
   int   BLAS_sussm   (enum   blas_order_type  order,  enum  blas_trans_type  transT,  int  nrhs,  float  alpha,
       blas_sparse_matrix T, float * b, int ldb)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B  \leftarrow  \alpha  T^{-1}  B,$  $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_sussm_  (enum  blas_order_type  * order, enum blas_trans_type * transT, int * nrhs, float * alpha,
       blas_sparse_matrix * T, float * b, int * ldb, int * istat)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B  \leftarrow  \alpha  T^{-1}  B,$  $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
           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.
   int BLAS_sussv (enum blas_trans_type transT, float alpha, blas_sparse_matrix T, float * x, int incx)
       Triangular  solve,  by  a  dense  vector.  Either  of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_sussv_ (enum blas_trans_type * transT, float * alpha, blas_sparse_matrix * T,  float  *  x,  int  *
       incx, int * istat)
       Triangular  solve,  by  a  dense  vector.  Either  of $X \leftarrow \alpha T^{-1}X,$ $X \leftarrow \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
           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.
   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.
   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.
   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.
   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.
   int BLAS_usgp (blas_sparse_matrix A, int 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.
   void blas_usgp_ (blas_sparse_matrix * A, int * 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.
   int BLAS_ussp (blas_sparse_matrix A, int 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.
   void blas_ussp_ (blas_sparse_matrix * A, int * 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.
   int BLAS_zusaxpy (int nnz, const void * alpha, const void * x, const int * indx, void *  y,  int  incy,  enum
       blas_base_type index_base)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
       Returns:
           On success, 0 is returned; on error, -1.
       Warning:
           Sparse BLAS Level 1 has been implemented and is working, although not with performance in mind.
   void  blas_zusaxpy_  (int  * nnz, const void * alpha, const void * x, const int * indx, void * y, int * incy,
       enum blas_base_type * index_base, int * istat)
       Sparse vector update: $Y \leftarrow \alpha X + Y$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 $X$ before accumulating to $Y$.
           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 and is working, although not with performance in mind.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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 $A$ in case of success, or set it to -1 on error.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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.
   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_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.
   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 $A$ in case of success, or set it to -1 on error.
   int BLAS_zusdot (enum blas_conj_type conj, int nnz, const void * x, const int * indx, const  void  *  y,  int
       incy, void * r, enum blas_base_type index_base)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_zusdot_  (enum blas_conj_type * conj, int * nnz, const void * x, const int * indx, const void * y,
       int * incy, void * r, enum blas_base_type * index_base, int * istat)
       Sparse dot product. $r \leftarrow X^T Y,$ $r \leftarrow X^H Y$
       Parameters:
           r Sparse dot result array.
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_zusga (int nnz, const void * y,  int  incy,  void  *  x,  const  int  *  indx,  enum  blas_base_type
       index_base)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void  blas_zusga_  (int  * nnz, const void * y, int * incy, void * x, const int * indx, enum blas_base_type *
       index_base, int * istat)
       Sparse gather. $X \leftarrow Y |_x$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_zusget_diag (blas_sparse_matrix A, void * d)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   void blas_zusget_diag_ (blas_sparse_matrix * A, void * d, int * istat)
       Get matrix diagonal. $d\leftarrow diag(A)$.
       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.
   int BLAS_zusget_element (blas_sparse_matrix A, int i, int j, void * v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_zusget_element_ (blas_sparse_matrix * A, int * i, int * j, void * v, int * istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_zusget_infinity_norm (blas_sparse_matrix A, void * in, 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.
   void  blas_zusget_infinity_norm_  (blas_sparse_matrix  *  A,  void  * in, 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.
   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.
   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.
   int BLAS_zusget_rows_nnz (blas_sparse_matrix A, int fr, 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.
   void blas_zusget_rows_nnz_ (blas_sparse_matrix * A, int * fr, 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.
   int BLAS_zusget_rows_sparse (blas_sparse_matrix A, void * VA, int * IA, int * JA, int * nnz, int fr, 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.
   void blas_zusget_rows_sparse_ (blas_sparse_matrix * A, void * VA, int * IA, int * JA, int * nnz,  int  *  fr,
       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.
   int BLAS_zusgz (int nnz, void * y, int incy, void * x, const int * indx, enum blas_base_type index_base)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_zusgz_ (int * nnz, void * y, int * incy, void  *  x,  const  int  *  indx,  enum  blas_base_type  *
       index_base, int * istat)
       Sparse gather and zero. $X \leftarrow Y |_x;Y|_x\leftarrow 0$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int  BLAS_zusmm  (enum  blas_order_type  order,  enum  blas_trans_type  transA, int nrhs, const void * alpha,
       blas_sparse_matrix A, const void * b, int ldb, void * c, int ldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_zusmm_ (enum blas_order_type * order, enum blas_trans_type * transA,  int  *  nrhs,  const  void  *
       alpha, blas_sparse_matrix * A, const void * b, int * ldb, void * c, int * ldc, int * istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C \leftarrow \alpha AB+C,$ $C \leftarrow \alpha
       A^T B+C,$ $C \leftarrow \alpha A^H B+C$, depending on the value of transA.
       Parameters:
           order layour of the dense array.
           transA Transposition operator for matrix A.
           nrhs Number of right hand side columns.
           A A valid matrix handle.
           alpha Value for $ \alpha $.
           b Dense vector b.
           ldb Leading dimension of b.
           c Dense vector c.
           ldc Leading dimension of c.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int  BLAS_zusmv  (enum  blas_trans_type transA, const void * alpha, blas_sparse_matrix A, const void * x, int
       incx, void * y, int incy)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By setting the blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any  time)  the  next
           multiplication  routine  call  (either of BLAS_dusmv, BLAS_susmv, BLAS_zusmv, BLAS_cusmv, BLAS_dusmm,
           BLAS_susmm, BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the  effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number  of  executing  threads  for this matrix will be determined once, at matrix assembly time, and
           employed irrespective of the default threads count (different values for transposed  and  untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure  time,  the  RSB_NUM_THREADS  environment  variable  will  override the number of executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_zusmv_ (enum blas_trans_type * transA, const void * alpha, blas_sparse_matrix * A, const void *  x,
       int * incx, void * y, int * incy, int * istat)
       Multiply by a dense vector. Either of $Y \leftarrow \alpha A X + Y ,$ $Y \leftarrow \alpha A^T X + Y,$ $Y
       \leftarrow \alpha A^H X + Y$, depending on the value of transA.
       Parameters:
           transA Transposition operator for matrix A.
           alpha Value for $ \alpha $.
           A A valid matrix handle.
           x Dense vector x.
           incx Stride of x.
           y Dense vector y.
           incy Stride of y.
       Note:
           By  setting  the  blas_rsb_autotune_next_operation  property  via  BLAS_ussp  (at  any time) the next
           multiplication routine call (either of BLAS_dusmv, BLAS_susmv,  BLAS_zusmv,  BLAS_cusmv,  BLAS_dusmm,
           BLAS_susmm,  BLAS_zusmm,  BLAS_cusmm)  will  invoke  autotuning  before  carrying  out  the effective
           operation. The tuning will take in account parameters like transposition, number of right hand sides,
           and scaling constants. By setting the blas_rsb_spmv_autotuning_on property via BLAS_ussp, the default
           number of executing threads for this matrix will be determined once, at  matrix  assembly  time,  and
           employed  irrespective  of the default threads count (different values for transposed and untrasposed
           multiply). This can be overridden only by setting the RSB_NUM_THREADS environment variable.
       See also:
           On the topic of autotuning, see also rsb_tune_spmm. If --enable-rsb-num-threads has been specified at
           configure time, the RSB_NUM_THREADS environment  variable  will  override  the  number  of  executing
           threads specified by OMP_NUM_THREADS. (See also RSB_IO_WANT_EXECUTING_THREADS).
       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.
   int BLAS_zusrows_scale (blas_sparse_matrix A, const void * d, 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.
   void blas_zusrows_scale_ (blas_sparse_matrix * A, const void * d, 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.
   int  BLAS_zussc  (int  nnz,  const  void  *  x,  void  *  y,  int incy, const int * indx, enum blas_base_type
       index_base)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   void blas_zussc_ (int * nnz, const void * x, void * y, int * incy, const int * indx,  enum  blas_base_type  *
       index_base, int * istat)
       Sparse scatter: $Y |_x\leftarrow X$.
       Parameters:
           y Array for $Y$ vector.
           x Array for $X$ vector.
           nnz Size of $X$and $Y$ vectors.
           indx Is the array of indices at which sparse vector $X$ 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 and is working, although not with performance in mind.
   int BLAS_zusset_element (blas_sparse_matrix A, int i, int j, void * v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   void blas_zusset_element_ (blas_sparse_matrix * A, int * i, int * j, void * v, int * istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       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.
   int BLAS_zusset_elements (blas_sparse_matrix A, const int * ia, const int * ja, const void * va, 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.
   void  blas_zusset_elements_  (blas_sparse_matrix  * A, const int * ia, const int * ja, const void * va, 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.
   int BLAS_zussm (enum blas_order_type order, enum blas_trans_type  transT,  int  nrhs,  const  void  *  alpha,
       blas_sparse_matrix T, void * b, int ldb)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
       Returns:
           On success, 0 is returned; on error, -1.
   void blas_zussm_ (enum blas_order_type * order, enum blas_trans_type * transT,  int  *  nrhs,  const  void  *
       alpha, blas_sparse_matrix * T, void * b, int * ldb, int * istat)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B \leftarrow \alpha T^{-1} B,$ $B
       \leftarrow \alpha T^{-T} B,$ $B \leftarrow \alpha T^{-H} B$, depending on the value of transT.
       Parameters:
           order layour of the dense array.
           transT Transposition operator for matrix T.
           nrhs Number of right hand side columns.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           b Dense vector b.
           ldb Leading dimension of b.
           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.
   int BLAS_zussv (enum blas_trans_type transT, const void * alpha, blas_sparse_matrix T, void * x, int incx)
       Triangular solve, by a dense vector. Either of  $X  \leftarrow  \alpha  T^{-1}X,$  $X  \leftarrow  \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
       Returns:
           On success, 0 is returned; on error, -1.
   void  blas_zussv_ (enum blas_trans_type * transT, const void * alpha, blas_sparse_matrix * T, void * x, int *
       incx, int * istat)
       Triangular solve, by a dense vector. Either of  $X  \leftarrow  \alpha  T^{-1}X,$  $X  \leftarrow  \alpha
       T^{-T}X,$ $X \leftarrow \alpha T^{-H}X$, depending on the value of transT.
       Parameters:
           transT Transposition operator for matrix T.
           alpha Value for $ \alpha $.
           T A valid triangular matrix handle.
           x Dense vector x.
           incx Stride of x.
           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.
   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

       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.