nist_spblas.cc

稀疏矩阵运算库C++版本的

}


template <class T>
int BLAS_xussv(enum blas_trans_type transa, const T& alpha, 
    blas_sparse_matrix A, T *x, int incx)
{
  TSp_mat<T> *M = 
        (TSp_mat<T> *) Table[A];

  ASSERT_RETURN(M->is_valid(), 1);

  return M->ussv(transa, alpha, x, incx);
}

template <class T>
int BLAS_xussm(enum blas_order_type orderA, enum blas_trans_type transa, 
    int nrhs, const T& alpha, blas_sparse_matrix A, T *C, int ldC)
{
  TSp_mat<T> *M = 
        (TSp_mat<T> *) Table[A];

  ASSERT_RETURN(M->is_valid(), 1);

  return M->ussm(orderA, transa, nrhs, alpha, C, ldC);
}

/*   --- end of generic rouintes ---- */


/*********/
/*  ----  double  Level 1 rouintes ----- */
/*********/

 void BLAS_DOUBLE_NAME(usdot)( 
    enum blas_conj_type conj_flag, 
    int  nz, 
    SPBLAS_VECTOR_DOUBLE_IN x,  
    const int *index,  
    SPBLAS_VECTOR_DOUBLE_IN y, 
    int incy, 
    SPBLAS_DOUBLE_OUT r, 
    enum blas_base_type index_base)
{
   BLAS_xusdot(conj_flag, nz, 
          SPBLAS_TO_VECTOR_DOUBLE_IN( x ), index, 
          SPBLAS_TO_VECTOR_DOUBLE_IN( y ), incy, 
          SPBLAS_TO_DOUBLE_OUT( r ), index_base);
}

 void BLAS_DOUBLE_NAME(usaxpy)(
    int nz, 
    SPBLAS_DOUBLE_IN alpha, 
    SPBLAS_VECTOR_DOUBLE_IN x, 
    const int *index, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT y, 
    int incy, 
    enum blas_base_type index_base)
{
  BLAS_xusaxpy(nz, SPBLAS_TO_DOUBLE_IN( alpha ), 
      SPBLAS_TO_VECTOR_DOUBLE_IN( x ), index, 
      SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( y ), 
      incy, index_base);
}

 void BLAS_DOUBLE_NAME(usga)( 
    int nz, 
    SPBLAS_VECTOR_DOUBLE_IN y, 
    int incy, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusga( nz, SPBLAS_TO_VECTOR_DOUBLE_IN( y ), incy, 
        SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( x ), indx, index_base);

}

 void BLAS_DOUBLE_NAME(usgz)( 
    int nz, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT y, 
    int incy, 
    SPBLAS_VECTOR_DOUBLE_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusgz(nz, SPBLAS_TO_DOUBLE_IN_OUT(y ), incy, SPBLAS_TO_DOUBLE_OUT(  x ), 
    indx, index_base);
}


 void BLAS_DOUBLE_NAME(ussc)(
    int nz, 
    SPBLAS_VECTOR_DOUBLE_IN x, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT y, 
    int incy, 
    const int *index, 
    enum blas_base_type index_base)
{
  BLAS_xussc(nz, SPBLAS_TO_VECTOR_DOUBLE_IN( x ), 
  SPBLAS_TO_DOUBLE_IN_OUT( y ), incy, index, 
  index_base);
}

/*  DOUBLE Level 2/3 creation routines */

int BLAS_DOUBLE_NAME(uscr_begin)(int M, int N)
{
  TSp_mat<DOUBLE> *A = new TSp_mat<DOUBLE>(M, N);
  TSp_MAT_SET_DOUBLE(A);

  return Table_insert(A);
}

blas_sparse_matrix BLAS_DOUBLE_NAME(uscr_block_begin)( 
    int Mb, int Nb, int k, int l )
{
  TSp_mat<DOUBLE> *A = new TSp_mat<DOUBLE>(Mb*k, Nb*l);

  TSp_MAT_SET_DOUBLE(A);
  A->set_const_block_parameters(Mb, Nb, k, l);

  return Table_insert(A);
}

blas_sparse_matrix BLAS_DOUBLE_NAME(uscr_variable_block_begin)( 
    int Mb, int Nb, const int *k, const int *l )
{
  TSp_mat<DOUBLE> *A = new TSp_mat<DOUBLE>(  
                accumulate(k, k+Mb, 0), accumulate(l, l+Nb, 0) );

  TSp_MAT_SET_DOUBLE(A);
  A->set_var_block_parameters(Mb, Nb, k, l);

  return Table_insert(A);

}

/*  DOUBLE Level 2/3 insertion routines */

int BLAS_DOUBLE_NAME(uscr_insert_entry)( 
    blas_sparse_matrix A, SPBLAS_DOUBLE_IN val, int i, int j )
{
  return BLAS_xuscr_insert_entry(A, SPBLAS_TO_DOUBLE_IN( val ), i, j);
}

int BLAS_DOUBLE_NAME(uscr_insert_entries)( 
    blas_sparse_matrix A, int nz, 
    SPBLAS_VECTOR_DOUBLE_IN val, 
    const int *indx, const int *jndx )
{
  return BLAS_xuscr_insert_entries(A, nz, SPBLAS_TO_VECTOR_DOUBLE_IN( val ), indx, jndx);
}

int BLAS_DOUBLE_NAME(uscr_insert_col)( 
    blas_sparse_matrix A, int j, int nz, 
    SPBLAS_VECTOR_DOUBLE_IN val, const int *indx )
{
  return BLAS_xuscr_insert_col(A, j, nz, SPBLAS_TO_VECTOR_DOUBLE_IN( val ), indx);
}

int BLAS_DOUBLE_NAME(uscr_insert_row)( 
  blas_sparse_matrix A, int i, int nz,
  SPBLAS_VECTOR_DOUBLE_IN val, const int *indx );

int BLAS_DOUBLE_NAME(uscr_insert_clique)( 
    blas_sparse_matrix A, 
    const int k, 
    const int l,
    SPBLAS_VECTOR_DOUBLE_IN val, 
    const int row_stride,
    const int col_stride, 
    const int *indx,
    const int *jndx );

int BLAS_DOUBLE_NAME(uscr_insert_block)( 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_DOUBLE_IN val,
    int row_stride, 
    int col_stride, 
    int i, int j )
{
  return BLAS_xuscr_insert_block(
        A, SPBLAS_TO_VECTOR_DOUBLE_IN( val ), 
        row_stride, col_stride, i, j);
}

int BLAS_DOUBLE_NAME(uscr_end)(blas_sparse_matrix A)
{
  return BLAS_xuscr_end(A);
}

/*  DOUBLE Level 2/3 computational routines */

 int BLAS_DOUBLE_NAME(usmv)(enum 
    blas_trans_type transa, 
    SPBLAS_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_DOUBLE_IN x, 
    int incx, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT y, 
    int incy )
{
  return BLAS_xusmv(
      transa,   SPBLAS_TO_DOUBLE_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_DOUBLE_IN( x ), incx, 
      SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( y ), incy);
}

int BLAS_DOUBLE_NAME(usmm)( 
    enum blas_order_type order, 
    enum blas_trans_type transa,
    int nrhs, 
    SPBLAS_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_DOUBLE_IN b,
    int ldb, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT c, 
    int ldc )
{
  return BLAS_xusmm(
      order, transa, nrhs, 
      SPBLAS_TO_DOUBLE_IN( alpha), A, 
      SPBLAS_TO_VECTOR_DOUBLE_IN(b), ldb, 
      SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( c ), ldc);
}

int BLAS_DOUBLE_NAME(ussv)( 
    enum blas_trans_type transa, 
    SPBLAS_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT x, 
    int incx )
{
  return BLAS_xussv( transa, 
        SPBLAS_TO_DOUBLE_IN( alpha ), A, 
        SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( x ), 
        incx);
}


int BLAS_DOUBLE_NAME(ussm)( 
    enum blas_order_type order, 
    enum blas_trans_type transt,
    int nrhs, 
    SPBLAS_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_DOUBLE_IN_OUT b, 
    int ldb )
{
  return BLAS_xussm(order, transt, nrhs, 
      SPBLAS_TO_DOUBLE_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_DOUBLE_IN_OUT( b ), ldb);
}


/*  ----   end of DOUBLE routines -------  */




 void BLAS_COMPLEX_DOUBLE_NAME(usdot)( 
    enum blas_conj_type conj_flag, 
    int  nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN x,  
    const int *index,  
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN y, 
    int incy, 
    SPBLAS_COMPLEX_DOUBLE_OUT r, 
    enum blas_base_type index_base)
{
   BLAS_xusdot(conj_flag, nz, 
          SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( x ), index, 
          SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( y ), incy, 
          SPBLAS_TO_COMPLEX_DOUBLE_OUT( r ), index_base);
}

 void BLAS_COMPLEX_DOUBLE_NAME(usaxpy)(
    int nz, 
    SPBLAS_COMPLEX_DOUBLE_IN alpha, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN x, 
    const int *index, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT y, 
    int incy, 
    enum blas_base_type index_base)
{
  BLAS_xusaxpy(nz, SPBLAS_TO_COMPLEX_DOUBLE_IN( alpha ), 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( x ), index, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( y ), 
      incy, index_base);
}

 void BLAS_COMPLEX_DOUBLE_NAME(usga)( 
    int nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN y, 
    int incy, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusga( nz, SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( y ), incy, 
        SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( x ), indx, index_base);

}

 void BLAS_COMPLEX_DOUBLE_NAME(usgz)( 
    int nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT y, 
    int incy, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusgz(nz, SPBLAS_TO_COMPLEX_DOUBLE_IN_OUT(y ), incy, SPBLAS_TO_COMPLEX_DOUBLE_OUT(  x ), 
    indx, index_base);
}


 void BLAS_COMPLEX_DOUBLE_NAME(ussc)(
    int nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN x, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT y, 
    int incy, 
    const int *index, 
    enum blas_base_type index_base)
{
  BLAS_xussc(nz, SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( x ), 
  SPBLAS_TO_COMPLEX_DOUBLE_IN_OUT( y ), incy, index, 
  index_base);
}

/*  COMPLEX_DOUBLE Level 2/3 creation routines */

int BLAS_COMPLEX_DOUBLE_NAME(uscr_begin)(int M, int N)
{
  TSp_mat<COMPLEX_DOUBLE> *A = new TSp_mat<COMPLEX_DOUBLE>(M, N);
  TSp_MAT_SET_COMPLEX_DOUBLE(A);

  return Table_insert(A);
}

blas_sparse_matrix BLAS_COMPLEX_DOUBLE_NAME(uscr_block_begin)( 
    int Mb, int Nb, int k, int l )
{
  TSp_mat<COMPLEX_DOUBLE> *A = new TSp_mat<COMPLEX_DOUBLE>(Mb*k, Nb*l);

  TSp_MAT_SET_COMPLEX_DOUBLE(A);
  A->set_const_block_parameters(Mb, Nb, k, l);

  return Table_insert(A);
}

blas_sparse_matrix BLAS_COMPLEX_DOUBLE_NAME(uscr_variable_block_begin)( 
    int Mb, int Nb, const int *k, const int *l )
{
  TSp_mat<COMPLEX_DOUBLE> *A = new TSp_mat<COMPLEX_DOUBLE>(  
                accumulate(k, k+Mb, 0), accumulate(l, l+Nb, 0) );

  TSp_MAT_SET_COMPLEX_DOUBLE(A);
  A->set_var_block_parameters(Mb, Nb, k, l);

  return Table_insert(A);

}

/*  COMPLEX_DOUBLE Level 2/3 insertion routines */

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_entry)( 
    blas_sparse_matrix A, SPBLAS_COMPLEX_DOUBLE_IN val, int i, int j )
{
  return BLAS_xuscr_insert_entry(A, SPBLAS_TO_COMPLEX_DOUBLE_IN( val ), i, j);
}

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_entries)( 
    blas_sparse_matrix A, int nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN val, 
    const int *indx, const int *jndx )
{
  return BLAS_xuscr_insert_entries(A, nz, SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( val ), indx, jndx);
}

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_col)( 
    blas_sparse_matrix A, int j, int nz, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN val, const int *indx )
{
  return BLAS_xuscr_insert_col(A, j, nz, SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( val ), indx);
}

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_row)( 
  blas_sparse_matrix A, int i, int nz,
  SPBLAS_VECTOR_COMPLEX_DOUBLE_IN val, const int *indx );

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_clique)( 
    blas_sparse_matrix A, 
    const int k, 
    const int l,
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN val, 
    const int row_stride,
    const int col_stride, 
    const int *indx,
    const int *jndx );

int BLAS_COMPLEX_DOUBLE_NAME(uscr_insert_block)( 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN val,
    int row_stride, 
    int col_stride, 
    int i, int j )
{
  return BLAS_xuscr_insert_block(
        A, SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( val ), 
        row_stride, col_stride, i, j);
}

int BLAS_COMPLEX_DOUBLE_NAME(uscr_end)(blas_sparse_matrix A)
{
  return BLAS_xuscr_end(A);
}

/*  COMPLEX_DOUBLE Level 2/3 computational routines */

 int BLAS_COMPLEX_DOUBLE_NAME(usmv)(enum 
    blas_trans_type transa, 
    SPBLAS_COMPLEX_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN x, 
    int incx, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT y, 
    int incy )
{
  return BLAS_xusmv(
      transa,   SPBLAS_TO_COMPLEX_DOUBLE_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN( x ), incx, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( y ), incy);
}

int BLAS_COMPLEX_DOUBLE_NAME(usmm)( 
    enum blas_order_type order, 
    enum blas_trans_type transa,
    int nrhs, 
    SPBLAS_COMPLEX_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN b,
    int ldb, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT c, 
    int ldc )
{
  return BLAS_xusmm(
      order, transa, nrhs, 
      SPBLAS_TO_COMPLEX_DOUBLE_IN( alpha), A, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN(b), ldb, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( c ), ldc);
}

int BLAS_COMPLEX_DOUBLE_NAME(ussv)( 
    enum blas_trans_type transa, 
    SPBLAS_COMPLEX_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT x, 
    int incx )
{
  return BLAS_xussv( transa, 
        SPBLAS_TO_COMPLEX_DOUBLE_IN( alpha ), A, 
        SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( x ), 
        incx);
}


int BLAS_COMPLEX_DOUBLE_NAME(ussm)( 
    enum blas_order_type order, 
    enum blas_trans_type transt,
    int nrhs, 
    SPBLAS_COMPLEX_DOUBLE_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_DOUBLE_IN_OUT b, 
    int ldb )
{
  return BLAS_xussm(order, transt, nrhs, 
      SPBLAS_TO_COMPLEX_DOUBLE_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_COMPLEX_DOUBLE_IN_OUT( b ), ldb);
}