nist_spblas.cc

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

/*  ----   end of COMPLEX_COMPLEX_COMPLEX_DOUBLE routines -------  */


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

 void BLAS_FLOAT_NAME(usdot)( 
    enum blas_conj_type conj_flag, 
    int  nz, 
    SPBLAS_VECTOR_FLOAT_IN x,  
    const int *index,  
    SPBLAS_VECTOR_FLOAT_IN y, 
    int incy, 
    SPBLAS_FLOAT_OUT r, 
    enum blas_base_type index_base)
{
   BLAS_xusdot(conj_flag, nz, 
          SPBLAS_TO_VECTOR_FLOAT_IN( x ), index, 
          SPBLAS_TO_VECTOR_FLOAT_IN( y ), incy, 
          SPBLAS_TO_FLOAT_OUT( r ), index_base);
}

 void BLAS_FLOAT_NAME(usaxpy)(
    int nz, 
    SPBLAS_FLOAT_IN alpha, 
    SPBLAS_VECTOR_FLOAT_IN x, 
    const int *index, 
    SPBLAS_VECTOR_FLOAT_IN_OUT y, 
    int incy, 
    enum blas_base_type index_base)
{
  BLAS_xusaxpy(nz, SPBLAS_TO_FLOAT_IN( alpha ), 
      SPBLAS_TO_VECTOR_FLOAT_IN( x ), index, 
      SPBLAS_TO_VECTOR_FLOAT_IN_OUT( y ), 
      incy, index_base);
}

 void BLAS_FLOAT_NAME(usga)( 
    int nz, 
    SPBLAS_VECTOR_FLOAT_IN y, 
    int incy, 
    SPBLAS_VECTOR_FLOAT_IN_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusga( nz, SPBLAS_TO_VECTOR_FLOAT_IN( y ), incy, 
        SPBLAS_TO_VECTOR_FLOAT_IN_OUT( x ), indx, index_base);

}

 void BLAS_FLOAT_NAME(usgz)( 
    int nz, 
    SPBLAS_VECTOR_FLOAT_IN_OUT y, 
    int incy, 
    SPBLAS_VECTOR_FLOAT_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusgz(nz, SPBLAS_TO_FLOAT_IN_OUT(y ), incy, SPBLAS_TO_FLOAT_OUT(  x ), 
    indx, index_base);
}


 void BLAS_FLOAT_NAME(ussc)(
    int nz, 
    SPBLAS_VECTOR_FLOAT_IN x, 
    SPBLAS_VECTOR_FLOAT_IN_OUT y, 
    int incy, 
    const int *index, 
    enum blas_base_type index_base)
{
  BLAS_xussc(nz, SPBLAS_TO_VECTOR_FLOAT_IN( x ), 
  SPBLAS_TO_FLOAT_IN_OUT( y ), incy, index, 
  index_base);
}

/*  FLOAT Level 2/3 creation routines */

int BLAS_FLOAT_NAME(uscr_begin)(int M, int N)
{
  TSp_mat<FLOAT> *A = new TSp_mat<FLOAT>(M, N);
  TSp_MAT_SET_FLOAT(A);

  return Table_insert(A);
}

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

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

  return Table_insert(A);
}

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

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

  return Table_insert(A);

}

/*  FLOAT Level 2/3 insertion routines */

int BLAS_FLOAT_NAME(uscr_insert_entry)( 
    blas_sparse_matrix A, SPBLAS_FLOAT_IN val, int i, int j )
{
  return BLAS_xuscr_insert_entry(A, SPBLAS_TO_FLOAT_IN( val ), i, j);
}

int BLAS_FLOAT_NAME(uscr_insert_entries)( 
    blas_sparse_matrix A, int nz, 
    SPBLAS_VECTOR_FLOAT_IN val, 
    const int *indx, const int *jndx )
{
  return BLAS_xuscr_insert_entries(A, nz, SPBLAS_TO_VECTOR_FLOAT_IN( val ), indx, jndx);
}

int BLAS_FLOAT_NAME(uscr_insert_col)( 
    blas_sparse_matrix A, int j, int nz, 
    SPBLAS_VECTOR_FLOAT_IN val, const int *indx )
{
  return BLAS_xuscr_insert_col(A, j, nz, SPBLAS_TO_VECTOR_FLOAT_IN( val ), indx);
}

int BLAS_FLOAT_NAME(uscr_insert_row)( 
  blas_sparse_matrix A, int i, int nz,
  SPBLAS_VECTOR_FLOAT_IN val, const int *indx );

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

int BLAS_FLOAT_NAME(uscr_insert_block)( 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_FLOAT_IN val,
    int row_stride, 
    int col_stride, 
    int i, int j )
{
  return BLAS_xuscr_insert_block(
        A, SPBLAS_TO_VECTOR_FLOAT_IN( val ), 
        row_stride, col_stride, i, j);
}

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

/*  FLOAT Level 2/3 computational routines */

 int BLAS_FLOAT_NAME(usmv)(enum 
    blas_trans_type transa, 
    SPBLAS_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_FLOAT_IN x, 
    int incx, 
    SPBLAS_VECTOR_FLOAT_IN_OUT y, 
    int incy )
{
  return BLAS_xusmv(
      transa,   SPBLAS_TO_FLOAT_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_FLOAT_IN( x ), incx, 
      SPBLAS_TO_VECTOR_FLOAT_IN_OUT( y ), incy);
}

int BLAS_FLOAT_NAME(usmm)( 
    enum blas_order_type order, 
    enum blas_trans_type transa,
    int nrhs, 
    SPBLAS_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_FLOAT_IN b,
    int ldb, 
    SPBLAS_VECTOR_FLOAT_IN_OUT c, 
    int ldc )
{
  return BLAS_xusmm(
      order, transa, nrhs, 
      SPBLAS_TO_FLOAT_IN( alpha), A, 
      SPBLAS_TO_VECTOR_FLOAT_IN(b), ldb, 
      SPBLAS_TO_VECTOR_FLOAT_IN_OUT( c ), ldc);
}

int BLAS_FLOAT_NAME(ussv)( 
    enum blas_trans_type transa, 
    SPBLAS_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_FLOAT_IN_OUT x, 
    int incx )
{
  return BLAS_xussv( transa, 
        SPBLAS_TO_FLOAT_IN( alpha ), A, 
        SPBLAS_TO_VECTOR_FLOAT_IN_OUT( x ), 
        incx);
}


int BLAS_FLOAT_NAME(ussm)( 
    enum blas_order_type order, 
    enum blas_trans_type transt,
    int nrhs, 
    SPBLAS_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_FLOAT_IN_OUT b, 
    int ldb )
{
  return BLAS_xussm(order, transt, nrhs, 
      SPBLAS_TO_FLOAT_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_FLOAT_IN_OUT( b ), ldb);
}


/*  ----   end of FLOAT routines -------  */




 void BLAS_COMPLEX_FLOAT_NAME(usdot)( 
    enum blas_conj_type conj_flag, 
    int  nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN x,  
    const int *index,  
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN y, 
    int incy, 
    SPBLAS_COMPLEX_FLOAT_OUT r, 
    enum blas_base_type index_base)
{
   BLAS_xusdot(conj_flag, nz, 
          SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( x ), index, 
          SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( y ), incy, 
          SPBLAS_TO_COMPLEX_FLOAT_OUT( r ), index_base);
}

 void BLAS_COMPLEX_FLOAT_NAME(usaxpy)(
    int nz, 
    SPBLAS_COMPLEX_FLOAT_IN alpha, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN x, 
    const int *index, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT y, 
    int incy, 
    enum blas_base_type index_base)
{
  BLAS_xusaxpy(nz, SPBLAS_TO_COMPLEX_FLOAT_IN( alpha ), 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( x ), index, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( y ), 
      incy, index_base);
}

 void BLAS_COMPLEX_FLOAT_NAME(usga)( 
    int nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN y, 
    int incy, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusga( nz, SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( y ), incy, 
        SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( x ), indx, index_base);

}

 void BLAS_COMPLEX_FLOAT_NAME(usgz)( 
    int nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT y, 
    int incy, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_OUT x, 
    const int *indx,
    enum blas_base_type index_base )
{
  BLAS_xusgz(nz, SPBLAS_TO_COMPLEX_FLOAT_IN_OUT(y ), incy, SPBLAS_TO_COMPLEX_FLOAT_OUT(  x ), 
    indx, index_base);
}


 void BLAS_COMPLEX_FLOAT_NAME(ussc)(
    int nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN x, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT y, 
    int incy, 
    const int *index, 
    enum blas_base_type index_base)
{
  BLAS_xussc(nz, SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( x ), 
  SPBLAS_TO_COMPLEX_FLOAT_IN_OUT( y ), incy, index, 
  index_base);
}

/*  COMPLEX_FLOAT Level 2/3 creation routines */

int BLAS_COMPLEX_FLOAT_NAME(uscr_begin)(int M, int N)
{
  TSp_mat<COMPLEX_FLOAT> *A = new TSp_mat<COMPLEX_FLOAT>(M, N);
  TSp_MAT_SET_COMPLEX_FLOAT(A);

  return Table_insert(A);
}

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

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

  return Table_insert(A);
}

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

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

  return Table_insert(A);

}

/*  COMPLEX_FLOAT Level 2/3 insertion routines */

int BLAS_COMPLEX_FLOAT_NAME(uscr_insert_entry)( 
    blas_sparse_matrix A, SPBLAS_COMPLEX_FLOAT_IN val, int i, int j )
{
  return BLAS_xuscr_insert_entry(A, SPBLAS_TO_COMPLEX_FLOAT_IN( val ), i, j);
}

int BLAS_COMPLEX_FLOAT_NAME(uscr_insert_entries)( 
    blas_sparse_matrix A, int nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN val, 
    const int *indx, const int *jndx )
{
  return BLAS_xuscr_insert_entries(A, nz, SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( val ), indx, jndx);
}

int BLAS_COMPLEX_FLOAT_NAME(uscr_insert_col)( 
    blas_sparse_matrix A, int j, int nz, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN val, const int *indx )
{
  return BLAS_xuscr_insert_col(A, j, nz, SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( val ), indx);
}

int BLAS_COMPLEX_FLOAT_NAME(uscr_insert_row)( 
  blas_sparse_matrix A, int i, int nz,
  SPBLAS_VECTOR_COMPLEX_FLOAT_IN val, const int *indx );

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

int BLAS_COMPLEX_FLOAT_NAME(uscr_insert_block)( 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN val,
    int row_stride, 
    int col_stride, 
    int i, int j )
{
  return BLAS_xuscr_insert_block(
        A, SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( val ), 
        row_stride, col_stride, i, j);
}

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

/*  COMPLEX_FLOAT Level 2/3 computational routines */

 int BLAS_COMPLEX_FLOAT_NAME(usmv)(enum 
    blas_trans_type transa, 
    SPBLAS_COMPLEX_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN x, 
    int incx, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT y, 
    int incy )
{
  return BLAS_xusmv(
      transa,   SPBLAS_TO_COMPLEX_FLOAT_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN( x ), incx, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( y ), incy);
}

int BLAS_COMPLEX_FLOAT_NAME(usmm)( 
    enum blas_order_type order, 
    enum blas_trans_type transa,
    int nrhs, 
    SPBLAS_COMPLEX_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN b,
    int ldb, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT c, 
    int ldc )
{
  return BLAS_xusmm(
      order, transa, nrhs, 
      SPBLAS_TO_COMPLEX_FLOAT_IN( alpha), A, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN(b), ldb, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( c ), ldc);
}

int BLAS_COMPLEX_FLOAT_NAME(ussv)( 
    enum blas_trans_type transa, 
    SPBLAS_COMPLEX_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT x, 
    int incx )
{
  return BLAS_xussv( transa, 
        SPBLAS_TO_COMPLEX_FLOAT_IN( alpha ), A, 
        SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( x ), 
        incx);
}


int BLAS_COMPLEX_FLOAT_NAME(ussm)( 
    enum blas_order_type order, 
    enum blas_trans_type transt,
    int nrhs, 
    SPBLAS_COMPLEX_FLOAT_IN alpha, 
    blas_sparse_matrix A, 
    SPBLAS_VECTOR_COMPLEX_FLOAT_IN_OUT b, 
    int ldb )
{
  return BLAS_xussm(order, transt, nrhs, 
      SPBLAS_TO_COMPLEX_FLOAT_IN( alpha ), A, 
      SPBLAS_TO_VECTOR_COMPLEX_FLOAT_IN_OUT( b ), ldb);
}




/*  ----   end of COMPLEX_COMPLEX_COMPLEX_FLOAT routines -------  */