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

       librsb was written by Michele Martone; this documentation has been generated by Doxygen.

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

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

intBLAS_cusaxpy(constintnnz,constvoid*alpha,constvoid*x,constint*indx,void*y,constintincy,constenumblas_base_typeindex_base)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   voidblas_cusaxpy_(constint*nnz,constvoid*alpha,constvoid*x,constint*indx,void*y,constint*incy,constenumblas_base_type*index_base,int*istat)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   blas_sparse_matrixBLAS_cuscr_begin(intm,intn)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm Is the count of rows.
           n Is the count of columns.
       Returns
           A matrix handle in case of success, or -1 on error.
   voidblas_cuscr_begin_(int*m,int*n,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm 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_matrixBLAS_cuscr_block_begin(intMb,intNb,intk,intl)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersk,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.
   voidblas_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.
       Parametersk,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.
   intBLAS_cuscr_end(blas_sparse_matrixA)
       Makes an assembled matrix out of a matrix in build state. After this,  it  is  not  possible  anymore  to
       insert nonzeroes, but computational routines.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_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.
       ParametersA 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.

   intBLAS_cuscr_insert_block(blas_sparse_matrixA,constvoid*val,introw_stride,intcol_stride,inti,intj)
       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.
       ParametersA 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.
       SeealsoBLAS_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.
   voidblas_cuscr_insert_block_(blas_sparse_matrix*A,constvoid*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.
       ParametersA 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.
       SeealsoBLAS_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.
       Parametersistat 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.

   intBLAS_cuscr_insert_clique(blas_sparse_matrixA,constintk,constintl,constvoid*val,constintrow_stride,constintcol_stride,constint*indx,constint*jndx)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
   voidblas_cuscr_insert_clique_(blas_sparse_matrix*A,constint*k,constint*l,constvoid*val,constint*row_stride,constint*col_stride,constint*indx,constint*jndx,int*istat)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cuscr_insert_col(blas_sparse_matrixA,intj,intnnz,constvoid*val,constint*indx)
       Inserts  a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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.
   voidblas_cuscr_insert_col_(blas_sparse_matrix*A,int*j,int*nnz,constvoid*val,constint*indx,int*istat)
       Inserts  a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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.

   intBLAS_cuscr_insert_entries(blas_sparse_matrixA,intnnz,constvoid*val,constint*indx,constint*jndx)
       Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be  summed
       together.
       ParametersA 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.
   voidblas_cuscr_insert_entries_(blas_sparse_matrix*A,int*nnz,constvoid*val,constint*indx,constint*jndx,int*istat)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.

   intBLAS_cuscr_insert_entry(blas_sparse_matrixA,constvoid*val,inti,intj)
       Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_cuscr_insert_entry_(blas_sparse_matrix*A,constvoid*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.
       ParametersA 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.

   intBLAS_cuscr_insert_row(blas_sparse_matrixA,inti,intnnz,constvoid*val,constint*indx)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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.
   voidblas_cuscr_insert_row_(blas_sparse_matrix*A,int*i,int*nnz,constvoid*val,constint*indx,int*istat)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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_matrixBLAS_cuscr_variable_block_begin(intMb,intNb,constint*K,constint*L)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   voidblas_cuscr_variable_block_begin_(int*Mb,int*Nb,constint*K,constint*L,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   intBLAS_cusdot(constenumblas_conj_typeconj,constintnnz,constvoid*x,constint*indx,constvoid*y,constintincy,void*r,constenumblas_base_typeindex_base)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   voidblas_cusdot_(constenumblas_conj_type*conj,constint*nnz,constvoid*x,constint*indx,constvoid*y,constint*incy,void*r,constenumblas_base_type*index_base,int*istat)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   intBLAS_cusga(constintnnz,constvoid*y,constintincy,void*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   voidblas_cusga_(constint*nnz,constvoid*y,constint*incy,void*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   intBLAS_cusget_diag(blas_sparse_matrixA,void*d)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
   voidblas_cusget_diag_(blas_sparse_matrix*A,void*d,int*istat)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusget_element(blas_sparse_matrixA,constinti,constintj,void*v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_cusget_element_(blas_sparse_matrix*A,constint*i,constint*j,void*v,int*istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusget_infinity_norm(blas_sparse_matrixA,void*in,constenumblas_trans_typetrans)
       Get infinity norm of matrix.
       ParametersA 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.
   voidblas_cusget_infinity_norm_(blas_sparse_matrix*A,void*in,constenumblas_trans_type*trans,int*istat)
       Get infinity norm of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusget_matrix_nnz(blas_sparse_matrixA,int*nnz)
       Get nnz count of matrix.
       ParametersA 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.
   voidblas_cusget_matrix_nnz_(blas_sparse_matrix*A,int*nnz,int*istat)
       Get nnz count of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusget_rows_nnz(blas_sparse_matrixA,constintfr,constintlr,int*nnzp)
       Get nnz count of matrix row interval.
       ParametersA 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.
   voidblas_cusget_rows_nnz_(blas_sparse_matrix*A,constint*fr,constint*lr,int*nnzp,int*istat)
       Get nnz count of matrix row interval.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusget_rows_sparse(blas_sparse_matrixA,void*VA,int*IA,int*JA,int*nnz,constintfr,constintlr)
       Get sparse rows of matrix.
       ParametersA 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.
   voidblas_cusget_rows_sparse_(blas_sparse_matrix*A,void*VA,int*IA,int*JA,int*nnz,constint*fr,constint*lr,int*istat)
       Get sparse rows of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusgz(constintnnz,void*y,constintincy,void*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   voidblas_cusgz_(constint*nnz,void*y,constint*incy,void*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   intBLAS_cusmm(constenumblas_order_typeorder,constenumblas_trans_typetransA,constintnrhs,constvoid*alpha,constblas_sparse_matrixA,constvoid*b,constintldb,void*c,constintldc)
       Multiply  by  a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$ $C <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat configure time, theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_cusmm_(constenumblas_order_type*order,constenumblas_trans_type*transA,constint*nrhs,constvoid*alpha,constblas_sparse_matrix*A,constvoid*b,constint*ldb,void*c,constint*ldc,int*istat)
       Multiply  by  a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$ $C <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat configure time, theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_cusmv(constenumblas_trans_typetransA,constvoid*alpha,constblas_sparse_matrixA,constvoid*x,constintincx,void*y,constintincy)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_cusmv_(constenumblas_trans_type*transA,constvoid*alpha,constblas_sparse_matrix*A,constvoid*x,constint*incx,void*y,constint*incy,int*istat)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_cusrows_scale(blas_sparse_matrixA,constvoid*d,constenumblas_trans_typetrans)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
   voidblas_cusrows_scale_(blas_sparse_matrix*A,constvoid*d,constenumblas_trans_type*trans,int*istat)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cussc(constintnnz,constvoid*x,void*y,constintincy,constint*indx,constenumblas_base_typeindex_base)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   voidblas_cussc_(constint*nnz,constvoid*x,void*y,constint*incy,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   intBLAS_cusset_element(blas_sparse_matrixA,constinti,constintj,void*v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_cusset_element_(blas_sparse_matrix*A,constint*i,constint*j,void*v,int*istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_cusset_elements(blas_sparse_matrixA,constint*ia,constint*ja,constvoid*va,constintnnz)
       Set individual matrix nonzero  coefficients  values.  The  operation  is  pattern  preserving,  that  is,
       nonzeroes must already exist.
       ParametersA 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.
   voidblas_cusset_elements_(blas_sparse_matrix*A,constint*ia,constint*ja,constvoid*va,constint*nnz,int*istat)
       Set  individual  matrix  nonzero  coefficients  values.  The  operation  is  pattern preserving, that is,
       nonzeroes must already exist.
       ParametersA 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..
       Parametersistat 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.

   intBLAS_cussm(constenumblas_order_typeorder,constenumblas_trans_typetransT,constintnrhs,constvoid*alpha,constblas_sparse_matrixT,void*b,constintldb)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B <- alpha  T^{-1}  B,$  $B  <-  alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.
   voidblas_cussm_(constenumblas_order_type*order,constenumblas_trans_type*transT,constint*nrhs,constvoid*alpha,constblas_sparse_matrix*T,void*b,constint*ldb,int*istat)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B <- alpha  T^{-1}  B,$  $B  <-  alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.

   intBLAS_cussv(enumblas_trans_typetransT,constvoid*alpha,constblas_sparse_matrixT,void*x,constintincx)
       Triangular solve, by a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$  $X  <-  alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.
   voidblas_cussv_(enumblas_trans_type*transT,constvoid*alpha,constblas_sparse_matrix*T,void*x,constint*incx,int*istat)
       Triangular solve, by a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$  $X  <-  alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.

   intBLAS_dusaxpy(constintnnz,doublealpha,constdouble*x,constint*indx,double*y,constintincy,constenumblas_base_typeindex_base)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   voidblas_dusaxpy_(constint*nnz,double*alpha,constdouble*x,constint*indx,double*y,constint*incy,constenumblas_base_type*index_base,int*istat)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   blas_sparse_matrixBLAS_duscr_begin(intm,intn)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm Is the count of rows.
           n Is the count of columns.
       Returns
           A matrix handle in case of success, or -1 on error.
   voidblas_duscr_begin_(int*m,int*n,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm 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_matrixBLAS_duscr_block_begin(intMb,intNb,intk,intl)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersk,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.
   voidblas_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.
       Parametersk,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.
   intBLAS_duscr_end(blas_sparse_matrixA)
       Makes  an  assembled  matrix  out  of  a matrix in build state. After this, it is not possible anymore to
       insert nonzeroes, but computational routines.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_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.
       ParametersA 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.

   intBLAS_duscr_insert_block(blas_sparse_matrixA,constdouble*val,introw_stride,intcol_stride,inti,intj)
       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.
       ParametersA 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.
       SeealsoBLAS_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.
   voidblas_duscr_insert_block_(blas_sparse_matrix*A,constdouble*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.
       ParametersA 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.
       SeealsoBLAS_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.
       Parametersistat 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.

   intBLAS_duscr_insert_clique(blas_sparse_matrixA,constintk,constintl,constdouble*val,constintrow_stride,constintcol_stride,constint*indx,constint*jndx)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
   voidblas_duscr_insert_clique_(blas_sparse_matrix*A,constint*k,constint*l,constdouble*val,constint*row_stride,constint*col_stride,constint*indx,constint*jndx,int*istat)
       Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate  entries  will
       be summed together.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_duscr_insert_col(blas_sparse_matrixA,intj,intnnz,constdouble*val,constint*indx)
       Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will  be
       summed together.
       ParametersA 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.
   voidblas_duscr_insert_col_(blas_sparse_matrix*A,int*j,int*nnz,constdouble*val,constint*indx,int*istat)
       Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will  be
       summed together.
       ParametersA 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.

   intBLAS_duscr_insert_entries(blas_sparse_matrixA,intnnz,constdouble*val,constint*indx,constint*jndx)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_duscr_insert_entries_(blas_sparse_matrix*A,int*nnz,constdouble*val,constint*indx,constint*jndx,int*istat)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.

   intBLAS_duscr_insert_entry(blas_sparse_matrixA,doubleval,inti,intj)
       Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_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.
       ParametersA 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.

   intBLAS_duscr_insert_row(blas_sparse_matrixA,inti,intnnz,constdouble*val,constint*indx)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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.
   voidblas_duscr_insert_row_(blas_sparse_matrix*A,int*i,int*nnz,constdouble*val,constint*indx,int*istat)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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_matrixBLAS_duscr_variable_block_begin(intMb,intNb,constint*K,constint*L)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   voidblas_duscr_variable_block_begin_(int*Mb,int*Nb,constint*K,constint*L,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   intBLAS_dusdot(constenumblas_conj_typeconj,constintnnz,constdouble*x,constint*indx,constdouble*y,constintincy,double*r,constenumblas_base_typeindex_base)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   voidblas_dusdot_(constenumblas_conj_type*conj,constint*nnz,constdouble*x,constint*indx,constdouble*y,constint*incy,double*r,constenumblas_base_type*index_base,int*istat)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   intBLAS_dusga(constintnnz,constdouble*y,constintincy,double*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   voidblas_dusga_(constint*nnz,constdouble*y,constint*incy,double*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   intBLAS_dusget_diag(blas_sparse_matrixA,double*d)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
   voidblas_dusget_diag_(blas_sparse_matrix*A,double*d,int*istat)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusget_element(blas_sparse_matrixA,constinti,constintj,double*v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_dusget_element_(blas_sparse_matrix*A,constint*i,constint*j,double*v,int*istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusget_infinity_norm(blas_sparse_matrixA,double*in,constenumblas_trans_typetrans)
       Get infinity norm of matrix.
       ParametersA 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.
   voidblas_dusget_infinity_norm_(blas_sparse_matrix*A,double*in,constenumblas_trans_type*trans,int*istat)
       Get infinity norm of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusget_matrix_nnz(blas_sparse_matrixA,int*nnz)
       Get nnz count of matrix.
       ParametersA 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.
   voidblas_dusget_matrix_nnz_(blas_sparse_matrix*A,int*nnz,int*istat)
       Get nnz count of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusget_rows_nnz(blas_sparse_matrixA,constintfr,constintlr,int*nnzp)
       Get nnz count of matrix row interval.
       ParametersA 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.
   voidblas_dusget_rows_nnz_(blas_sparse_matrix*A,constint*fr,constint*lr,int*nnzp,int*istat)
       Get nnz count of matrix row interval.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusget_rows_sparse(blas_sparse_matrixA,double*VA,int*IA,int*JA,int*nnz,constintfr,constintlr)
       Get sparse rows of matrix.
       ParametersA 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.
   voidblas_dusget_rows_sparse_(blas_sparse_matrix*A,double*VA,int*IA,int*JA,int*nnz,constint*fr,constint*lr,int*istat)
       Get sparse rows of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusgz(constintnnz,double*y,constintincy,double*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   voidblas_dusgz_(constint*nnz,double*y,constint*incy,double*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   intBLAS_dusmm(constenumblas_order_typeorder,constenumblas_trans_typetransA,constintnrhs,doublealpha,constblas_sparse_matrixA,constdouble*b,constintldb,double*c,constintldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$  $C  <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat  configure  time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_dusmm_(constenumblas_order_type*order,constenumblas_trans_type*transA,constint*nrhs,double*alpha,constblas_sparse_matrix*A,constdouble*b,constint*ldb,double*c,constint*ldc,int*istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$  $C  <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat  configure  time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_dusmv(constenumblas_trans_typetransA,doublealpha,constblas_sparse_matrixA,constdouble*x,constintincx,double*y,constintincy)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_dusmv_(constenumblas_trans_type*transA,double*alpha,constblas_sparse_matrix*A,constdouble*x,constint*incx,double*y,constint*incy,int*istat)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_dusrows_scale(blas_sparse_matrixA,constdouble*d,constenumblas_trans_typetrans)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
   voidblas_dusrows_scale_(blas_sparse_matrix*A,constdouble*d,constenumblas_trans_type*trans,int*istat)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dussc(constintnnz,constdouble*x,double*y,constintincy,constint*indx,constenumblas_base_typeindex_base)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   voidblas_dussc_(constint*nnz,constdouble*x,double*y,constint*incy,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   intBLAS_dusset_element(blas_sparse_matrixA,constinti,constintj,double*v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_dusset_element_(blas_sparse_matrix*A,constint*i,constint*j,double*v,int*istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_dusset_elements(blas_sparse_matrixA,constint*ia,constint*ja,constdouble*va,constintnnz)
       Set  individual  matrix  nonzero  coefficients  values.  The  operation  is  pattern preserving, that is,
       nonzeroes must already exist.
       ParametersA 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.
   voidblas_dusset_elements_(blas_sparse_matrix*A,constint*ia,constint*ja,constdouble*va,constint*nnz,int*istat)
       Set individual matrix nonzero  coefficients  values.  The  operation  is  pattern  preserving,  that  is,
       nonzeroes must already exist.
       ParametersA 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..
       Parametersistat 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.

   intBLAS_dussm(constenumblas_order_typeorder,constenumblas_trans_typetransT,constintnrhs,doublealpha,constblas_sparse_matrixT,double*b,constintldb)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B <- alpha T^{-1} B,$ $B <- alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.
   voidblas_dussm_(constenumblas_order_type*order,constenumblas_trans_type*transT,constint*nrhs,double*alpha,constblas_sparse_matrix*T,double*b,constint*ldb,int*istat)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B <- alpha T^{-1} B,$ $B <- alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.

   intBLAS_dussv(enumblas_trans_typetransT,doublealpha,constblas_sparse_matrixT,double*x,constintincx)
       Triangular  solve,  by  a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$ $X <- alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.
   voidblas_dussv_(enumblas_trans_type*transT,double*alpha,constblas_sparse_matrix*T,double*x,constint*incx,int*istat)
       Triangular  solve,  by  a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$ $X <- alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.

   intBLAS_susaxpy(constintnnz,floatalpha,constfloat*x,constint*indx,float*y,constintincy,constenumblas_base_typeindex_base)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   voidblas_susaxpy_(constint*nnz,float*alpha,constfloat*x,constint*indx,float*y,constint*incy,constenumblas_base_type*index_base,int*istat)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   blas_sparse_matrixBLAS_suscr_begin(intm,intn)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm Is the count of rows.
           n Is the count of columns.
       Returns
           A matrix handle in case of success, or -1 on error.
   voidblas_suscr_begin_(int*m,int*n,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm 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_matrixBLAS_suscr_block_begin(intMb,intNb,intk,intl)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersk,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.
   voidblas_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.
       Parametersk,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.
   intBLAS_suscr_end(blas_sparse_matrixA)
       Makes  an  assembled  matrix  out  of  a matrix in build state. After this, it is not possible anymore to
       insert nonzeroes, but computational routines.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_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.
       ParametersA 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.

   intBLAS_suscr_insert_block(blas_sparse_matrixA,constfloat*val,introw_stride,intcol_stride,inti,intj)
       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.
       ParametersA 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.
       SeealsoBLAS_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.
   voidblas_suscr_insert_block_(blas_sparse_matrix*A,constfloat*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.
       ParametersA 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.
       SeealsoBLAS_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.
       Parametersistat 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.

   intBLAS_suscr_insert_clique(blas_sparse_matrixA,constintk,constintl,constfloat*val,constintrow_stride,constintcol_stride,constint*indx,constint*jndx)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
   voidblas_suscr_insert_clique_(blas_sparse_matrix*A,constint*k,constint*l,constfloat*val,constint*row_stride,constint*col_stride,constint*indx,constint*jndx,int*istat)
       Inserts a whole clique in a matrix, assuming this is in build state. By default, duplicate  entries  will
       be summed together.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_suscr_insert_col(blas_sparse_matrixA,intj,intnnz,constfloat*val,constint*indx)
       Inserts a whole column in a matrix, assuming it is in build state. By default, duplicate entries will  be
       summed together.
       ParametersA 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.
   voidblas_suscr_insert_col_(blas_sparse_matrix*A,int*j,int*nnz,constfloat*val,constint*indx,int*istat)
       Inserts  a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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.

   intBLAS_suscr_insert_entries(blas_sparse_matrixA,intnnz,constfloat*val,constint*indx,constint*jndx)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_suscr_insert_entries_(blas_sparse_matrix*A,int*nnz,constfloat*val,constint*indx,constint*jndx,int*istat)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.

   intBLAS_suscr_insert_entry(blas_sparse_matrixA,floatval,inti,intj)
       Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_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.
       ParametersA 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.

   intBLAS_suscr_insert_row(blas_sparse_matrixA,inti,intnnz,constfloat*val,constint*indx)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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.
   voidblas_suscr_insert_row_(blas_sparse_matrix*A,int*i,int*nnz,constfloat*val,constint*indx,int*istat)
       Inserts  a  whole  row  in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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_matrixBLAS_suscr_variable_block_begin(intMb,intNb,constint*K,constint*L)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   voidblas_suscr_variable_block_begin_(int*Mb,int*Nb,constint*K,constint*L,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   intBLAS_susdot(constenumblas_conj_typeconj,constintnnz,constfloat*x,constint*indx,constfloat*y,constintincy,float*r,constenumblas_base_typeindex_base)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   voidblas_susdot_(constenumblas_conj_type*conj,constint*nnz,constfloat*x,constint*indx,constfloat*y,constint*incy,float*r,constenumblas_base_type*index_base,int*istat)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   intBLAS_susga(constintnnz,constfloat*y,constintincy,float*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   voidblas_susga_(constint*nnz,constfloat*y,constint*incy,float*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   intBLAS_susget_diag(blas_sparse_matrixA,float*d)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
   voidblas_susget_diag_(blas_sparse_matrix*A,float*d,int*istat)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susget_element(blas_sparse_matrixA,constinti,constintj,float*v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_susget_element_(blas_sparse_matrix*A,constint*i,constint*j,float*v,int*istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susget_infinity_norm(blas_sparse_matrixA,float*in,constenumblas_trans_typetrans)
       Get infinity norm of matrix.
       ParametersA 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.
   voidblas_susget_infinity_norm_(blas_sparse_matrix*A,float*in,constenumblas_trans_type*trans,int*istat)
       Get infinity norm of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susget_matrix_nnz(blas_sparse_matrixA,int*nnz)
       Get nnz count of matrix.
       ParametersA 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.
   voidblas_susget_matrix_nnz_(blas_sparse_matrix*A,int*nnz,int*istat)
       Get nnz count of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susget_rows_nnz(blas_sparse_matrixA,constintfr,constintlr,int*nnzp)
       Get nnz count of matrix row interval.
       ParametersA 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.
   voidblas_susget_rows_nnz_(blas_sparse_matrix*A,constint*fr,constint*lr,int*nnzp,int*istat)
       Get nnz count of matrix row interval.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susget_rows_sparse(blas_sparse_matrixA,float*VA,int*IA,int*JA,int*nnz,constintfr,constintlr)
       Get sparse rows of matrix.
       ParametersA 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.
   voidblas_susget_rows_sparse_(blas_sparse_matrix*A,float*VA,int*IA,int*JA,int*nnz,constint*fr,constint*lr,int*istat)
       Get sparse rows of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susgz(constintnnz,float*y,constintincy,float*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   voidblas_susgz_(constint*nnz,float*y,constint*incy,float*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   intBLAS_susmm(constenumblas_order_typeorder,constenumblas_trans_typetransA,constintnrhs,floatalpha,constblas_sparse_matrixA,constfloat*b,constintldb,float*c,constintldc)
       Multiply by a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$  $C  <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat  configure  time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_susmm_(constenumblas_order_type*order,constenumblas_trans_type*transA,constint*nrhs,float*alpha,constblas_sparse_matrix*A,constfloat*b,constint*ldb,float*c,constint*ldc,int*istat)
       Multiply by a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$  $C  <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat  configure  time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_susmv(constenumblas_trans_typetransA,floatalpha,constblas_sparse_matrixA,constfloat*x,constintincx,float*y,constintincy)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_susmv_(constenumblas_trans_type*transA,float*alpha,constblas_sparse_matrix*A,constfloat*x,constint*incx,float*y,constint*incy,int*istat)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_susrows_scale(blas_sparse_matrixA,constfloat*d,constenumblas_trans_typetrans)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
   voidblas_susrows_scale_(blas_sparse_matrix*A,constfloat*d,constenumblas_trans_type*trans,int*istat)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_sussc(constintnnz,constfloat*x,float*y,constintincy,constint*indx,constenumblas_base_typeindex_base)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   voidblas_sussc_(constint*nnz,constfloat*x,float*y,constint*incy,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   intBLAS_susset_element(blas_sparse_matrixA,constinti,constintj,float*v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_susset_element_(blas_sparse_matrix*A,constint*i,constint*j,float*v,int*istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_susset_elements(blas_sparse_matrixA,constint*ia,constint*ja,constfloat*va,constintnnz)
       Set  individual  matrix  nonzero  coefficients  values.  The  operation  is  pattern preserving, that is,
       nonzeroes must already exist.
       ParametersA 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.
   voidblas_susset_elements_(blas_sparse_matrix*A,constint*ia,constint*ja,constfloat*va,constint*nnz,int*istat)
       Set individual matrix nonzero  coefficients  values.  The  operation  is  pattern  preserving,  that  is,
       nonzeroes must already exist.
       ParametersA 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..
       Parametersistat 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.

   intBLAS_sussm(constenumblas_order_typeorder,constenumblas_trans_typetransT,constintnrhs,floatalpha,constblas_sparse_matrixT,float*b,constintldb)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B <- alpha T^{-1} B,$ $B <- alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.
   voidblas_sussm_(constenumblas_order_type*order,constenumblas_trans_type*transT,constint*nrhs,float*alpha,constblas_sparse_matrix*T,float*b,constint*ldb,int*istat)
       Triangular  solve,  by  a  dense  matrix (aka multi-vector). Either of $B <- alpha T^{-1} B,$ $B <- alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.

   intBLAS_sussv(enumblas_trans_typetransT,floatalpha,constblas_sparse_matrixT,float*x,constintincx)
       Triangular  solve,  by  a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$ $X <- alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.
   voidblas_sussv_(enumblas_trans_type*transT,float*alpha,constblas_sparse_matrix*T,float*x,constint*incx,int*istat)
       Triangular  solve,  by  a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$ $X <- alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.

   intBLAS_uscr_end(blas_sparse_matrixA)
       Makes an assembled matrix out of a matrix in build state. After this,  it  is  not  possible  anymore  to
       insert nonzeroes, but computational routines.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_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.
       ParametersA 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.

   intBLAS_usds(blas_sparse_matrixA)
       Destroys a matrix.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_usds_(blas_sparse_matrix*A,int*istat)
       Destroys a matrix.
       ParametersA 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.

   intBLAS_usgp(blas_sparse_matrixA,rsb_blas_pname_tpname)
       Get a matrix property.
       ParametersA 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.
   voidblas_usgp_(blas_sparse_matrix*A,rsb_blas_pname_t*pname,int*istat)
       Get a matrix property.
       ParametersA 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.

   intBLAS_ussp(blas_sparse_matrixA,rsb_blas_pname_tpname)
       Set a matrix property. Should be called just after creation, before nonzeroes insertion.
       ParametersA 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.
   voidblas_ussp_(blas_sparse_matrix*A,rsb_blas_pname_t*pname,int*istat)
       Set a matrix property. Should be called just after creation, before nonzeroes insertion.
       ParametersA 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.

   intBLAS_zusaxpy(constintnnz,constvoid*alpha,constvoid*x,constint*indx,void*y,constintincy,constenumblas_base_typeindex_base)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   voidblas_zusaxpy_(constint*nnz,constvoid*alpha,constvoid*x,constint*indx,void*y,constint*incy,constenumblas_base_type*index_base,int*istat)
       Sparse vector update: $Y <- alpha X + Y$.
       Parametersy 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, although not with performance in mind.
   blas_sparse_matrixBLAS_zuscr_begin(intm,intn)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm Is the count of rows.
           n Is the count of columns.
       Returns
           A matrix handle in case of success, or -1 on error.
   voidblas_zuscr_begin_(int*m,int*n,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersm 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_matrixBLAS_zuscr_block_begin(intMb,intNb,intk,intl)
       Allocates an empty matrix (A) and leaves it in build state.
       Parametersk,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.
   voidblas_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.
       Parametersk,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.
   intBLAS_zuscr_end(blas_sparse_matrixA)
       Makes an assembled matrix out of a matrix in build state. After this,  it  is  not  possible  anymore  to
       insert nonzeroes, but computational routines.
       ParametersA A valid matrix handle.
       Returns
           On success, 0 is returned; on error, -1.
   voidblas_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.
       ParametersA 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.

   intBLAS_zuscr_insert_block(blas_sparse_matrixA,constvoid*val,introw_stride,intcol_stride,inti,intj)
       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.
       ParametersA 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.
       SeealsoBLAS_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.
   voidblas_zuscr_insert_block_(blas_sparse_matrix*A,constvoid*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.
       ParametersA 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.
       SeealsoBLAS_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.
       Parametersistat 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.

   intBLAS_zuscr_insert_clique(blas_sparse_matrixA,constintk,constintl,constvoid*val,constintrow_stride,constintcol_stride,constint*indx,constint*jndx)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
   voidblas_zuscr_insert_clique_(blas_sparse_matrix*A,constint*k,constint*l,constvoid*val,constint*row_stride,constint*col_stride,constint*indx,constint*jndx,int*istat)
       Inserts  a  whole clique in a matrix, assuming this is in build state. By default, duplicate entries will
       be summed together.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zuscr_insert_col(blas_sparse_matrixA,intj,intnnz,constvoid*val,constint*indx)
       Inserts  a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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.
   voidblas_zuscr_insert_col_(blas_sparse_matrix*A,int*j,int*nnz,constvoid*val,constint*indx,int*istat)
       Inserts  a whole column in a matrix, assuming it is in build state. By default, duplicate entries will be
       summed together.
       ParametersA 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.

   intBLAS_zuscr_insert_entries(blas_sparse_matrixA,intnnz,constvoid*val,constint*indx,constint*jndx)
       Inserts entries in a matrix, assuming it is in build state. By default, duplicate entries will be  summed
       together.
       ParametersA 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.
   voidblas_zuscr_insert_entries_(blas_sparse_matrix*A,int*nnz,constvoid*val,constint*indx,constint*jndx,int*istat)
       Inserts  entries in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.

   intBLAS_zuscr_insert_entry(blas_sparse_matrixA,constvoid*val,inti,intj)
       Inserts an entry in a matrix, assuming it is in build state. By default, duplicate entries will be summed
       together.
       ParametersA 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.
   voidblas_zuscr_insert_entry_(blas_sparse_matrix*A,constvoid*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.
       ParametersA 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.

   intBLAS_zuscr_insert_row(blas_sparse_matrixA,inti,intnnz,constvoid*val,constint*indx)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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.
   voidblas_zuscr_insert_row_(blas_sparse_matrix*A,int*i,int*nnz,constvoid*val,constint*indx,int*istat)
       Inserts a whole row in a matrix, assuming it is in build state. By default,  duplicate  entries  will  be
       summed together.
       ParametersA 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_matrixBLAS_zuscr_variable_block_begin(intMb,intNb,constint*K,constint*L)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   voidblas_zuscr_variable_block_begin_(int*Mb,int*Nb,constint*K,constint*L,blas_sparse_matrix*A,int*istat)
       Allocates an empty matrix (A) and leaves it in build state.
       ParametersK,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.
   intBLAS_zusdot(constenumblas_conj_typeconj,constintnnz,constvoid*x,constint*indx,constvoid*y,constintincy,void*r,constenumblas_base_typeindex_base)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   voidblas_zusdot_(constenumblas_conj_type*conj,constint*nnz,constvoid*x,constint*indx,constvoid*y,constint*incy,void*r,constenumblas_base_type*index_base,int*istat)
       Sparse dot product. $r <- X^T Y,$ $r <- X^H Y$
       Parametersr 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, although not with performance in mind.
   intBLAS_zusga(constintnnz,constvoid*y,constintincy,void*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   voidblas_zusga_(constint*nnz,constvoid*y,constint*incy,void*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather. $X <- Y |_x$.
       Parametersy 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, although not with performance in mind.
   intBLAS_zusget_diag(blas_sparse_matrixA,void*d)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
   voidblas_zusget_diag_(blas_sparse_matrix*A,void*d,int*istat)
       Get matrix diagonal. $d <- diag(A)$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusget_element(blas_sparse_matrixA,constinti,constintj,void*v)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_zusget_element_(blas_sparse_matrix*A,constint*i,constint*j,void*v,int*istat)
       Get a single matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusget_infinity_norm(blas_sparse_matrixA,void*in,constenumblas_trans_typetrans)
       Get infinity norm of matrix.
       ParametersA 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.
   voidblas_zusget_infinity_norm_(blas_sparse_matrix*A,void*in,constenumblas_trans_type*trans,int*istat)
       Get infinity norm of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusget_matrix_nnz(blas_sparse_matrixA,int*nnz)
       Get nnz count of matrix.
       ParametersA 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.
   voidblas_zusget_matrix_nnz_(blas_sparse_matrix*A,int*nnz,int*istat)
       Get nnz count of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusget_rows_nnz(blas_sparse_matrixA,constintfr,constintlr,int*nnzp)
       Get nnz count of matrix row interval.
       ParametersA 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.
   voidblas_zusget_rows_nnz_(blas_sparse_matrix*A,constint*fr,constint*lr,int*nnzp,int*istat)
       Get nnz count of matrix row interval.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusget_rows_sparse(blas_sparse_matrixA,void*VA,int*IA,int*JA,int*nnz,constintfr,constintlr)
       Get sparse rows of matrix.
       ParametersA 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.
   voidblas_zusget_rows_sparse_(blas_sparse_matrix*A,void*VA,int*IA,int*JA,int*nnz,constint*fr,constint*lr,int*istat)
       Get sparse rows of matrix.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusgz(constintnnz,void*y,constintincy,void*x,constint*indx,constenumblas_base_typeindex_base)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   voidblas_zusgz_(constint*nnz,void*y,constint*incy,void*x,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse gather and zero. $X <- Y |_x;Y|_x <- 0$.
       Parametersy 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, although not with performance in mind.
   intBLAS_zusmm(constenumblas_order_typeorder,constenumblas_trans_typetransA,constintnrhs,constvoid*alpha,constblas_sparse_matrixA,constvoid*b,constintldb,void*c,constintldc)
       Multiply  by  a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$ $C <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat configure time, theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_zusmm_(constenumblas_order_type*order,constenumblas_trans_type*transA,constint*nrhs,constvoid*alpha,constblas_sparse_matrix*A,constvoid*b,constint*ldb,void*c,constint*ldc,int*istat)
       Multiply  by  a dense matrix (aka multi-vector). Either of $C <- alpha AB+C,$ $C <- alpha A^T B+C,$ $C <-
       alpha A^H B+C$, depending on the value of transA.
       Parametersorder 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.\nIf --enable-rsb-num-threads hasbeenspecifiedat configure time, theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_zusmv(constenumblas_trans_typetransA,constvoid*alpha,constblas_sparse_matrixA,constvoid*x,constintincx,void*y,constintincy)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Returns
           On success, 0 is returned; on error, -1.
   voidblas_zusmv_(constenumblas_trans_type*transA,constvoid*alpha,constblas_sparse_matrix*A,constvoid*x,constint*incx,void*y,constint*incy,int*istat)
       Multiply by a dense vector. Either of $Y <- alpha A   X + Y  ,$
        $Y <- alpha A^T X + Y,$
        $Y <- alpha A^H X + Y$, depending on the value of transA.
       ParameterstransA 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_operationpropertyviaBLAS_ussp(atanytime)thenextmultiplicationroutinecall(eitherofBLAS_dusmv,BLAS_susmv,BLAS_zusmv,BLAS_cusmv,BLAS_dusmm,BLAS_susmm,BLAS_zusmm,BLAS_cusmm)willinvokeautotuningbeforecarryingouttheeffectiveoperation.Thetuningwilltakeinaccountparametersliketransposition,numberofrighthandsides,andscalingconstants.Bysettingtheblas_rsb_spmv_autotuning_onpropertyviaBLAS_ussp,thedefaultnumberofexecutingthreadsforthismatrixwillbedeterminedonce,atmatrixassemblytime,andemployedirrespectiveofthedefaultthreadscount(differentvaluesfortransposedanduntransposedmultiply).ThiscanbeoverriddenonlybysettingtheRSB_NUM_THREADSenvironmentvariable.SeealsoOnthetopicofautotuning, seealsorsb_tune_spmm.
            If --enable-rsb-num-threads hasbeenspecifiedat configure time,  theRSB_NUM_THREADSenvironmentvariablewilloverridethenumberofexecutingthreadsspecifiedbyOMP_NUM_THREADS.(SeealsoRSB_IO_WANT_EXECUTING_THREADS).Parametersistat 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.

   intBLAS_zusrows_scale(blas_sparse_matrixA,constvoid*d,constenumblas_trans_typetrans)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
   voidblas_zusrows_scale_(blas_sparse_matrix*A,constvoid*d,constenumblas_trans_type*trans,int*istat)
       Scale rows interval of matrix by specified factor.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zussc(constintnnz,constvoid*x,void*y,constintincy,constint*indx,constenumblas_base_typeindex_base)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   voidblas_zussc_(constint*nnz,constvoid*x,void*y,constint*incy,constint*indx,constenumblas_base_type*index_base,int*istat)
       Sparse scatter: $Y |_x <- X$.
       Parametersy 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, although not with performance in mind.
   intBLAS_zusset_element(blas_sparse_matrixA,constinti,constintj,void*v)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
   voidblas_zusset_element_(blas_sparse_matrix*A,constint*i,constint*j,void*v,int*istat)
       Set a single (existing) matrix nonzero coefficient $A_{i,j}$.
       ParametersA 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.
       Parametersistat 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.

   intBLAS_zusset_elements(blas_sparse_matrixA,constint*ia,constint*ja,constvoid*va,constintnnz)
       Set individual matrix nonzero  coefficients  values.  The  operation  is  pattern  preserving,  that  is,
       nonzeroes must already exist.
       ParametersA 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.
   voidblas_zusset_elements_(blas_sparse_matrix*A,constint*ia,constint*ja,constvoid*va,constint*nnz,int*istat)
       Set  individual  matrix  nonzero  coefficients  values.  The  operation  is  pattern preserving, that is,
       nonzeroes must already exist.
       ParametersA 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..
       Parametersistat 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.

   intBLAS_zussm(constenumblas_order_typeorder,constenumblas_trans_typetransT,constintnrhs,constvoid*alpha,constblas_sparse_matrixT,void*b,constintldb)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B <- alpha  T^{-1}  B,$  $B  <-  alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.
   voidblas_zussm_(constenumblas_order_type*order,constenumblas_trans_type*transT,constint*nrhs,constvoid*alpha,constblas_sparse_matrix*T,void*b,constint*ldb,int*istat)
       Triangular solve, by a dense matrix (aka multi-vector). Either of $B <- alpha  T^{-1}  B,$  $B  <-  alpha
       T^{-T} B,$ $B <- alpha T^{-H} B$, depending on the value of transT.
       Parametersorder 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.

   intBLAS_zussv(enumblas_trans_typetransT,constvoid*alpha,constblas_sparse_matrixT,void*x,constintincx)
       Triangular solve, by a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$  $X  <-  alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.
   voidblas_zussv_(enumblas_trans_type*transT,constvoid*alpha,constblas_sparse_matrix*T,void*x,constint*incx,int*istat)
       Triangular solve, by a dense vector. Either of $X <- alpha T^{-1}X,$ $X <- alpha T^{-T}X,$  $X  <-  alpha
       T^{-H}X$, depending on the value of transT.
       ParameterstransT 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.

   blas_sparse_matrixrsb_blas_file_mtx_load(constrsb_char_t*filename,rsb_type_ttypecode)
       Load Matrix Market matrix file of specified type to a matrix, and return Sparse BLAS handler.
       Parametersfilename The specified matrix file name (cannot be NULL).
           typecode A valid type code for the desired output matrix (see matrix_type_symbols_section).
       Returns
           On success, a valid matrix handle will be returned. On error, blas_invalid_handle will be returned.
   structrsb_mtx_t*rsb_blas_get_mtx(blas_sparse_matrixA)
       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.
       ParametersA 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

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