fdurastante
/
psblas3
mirror of https://github.com/sfilippone/psblas3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Channge naming scheme for C types

Browse Source
merge-maint-par
sfilippone 2 weeks ago
parent 9b95e14b2c
commit 6d4ed9575a
31 changed files with 518 additions and 518 deletions
Show Stats Download Patch File Download Diff File

28
base/modules/psb_types.h
Unescape Escape View File

@ -10,29 +10,29 @@
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#endif #endif
typedef int32_t psb_m_t; typedef int32_t psb_c_m_t;
#if defined(PSB_IPK4) && defined(PSB_LPK4) #if defined(PSB_IPK4) && defined(PSB_LPK4)
typedef int32_t psb_i_t; typedef int32_t psb_c_i_t;
typedef int32_t psb_l_t; typedef int32_t psb_c_l_t;
#elif defined(PSB_IPK4) && defined(PSB_LPK8) #elif defined(PSB_IPK4) && defined(PSB_LPK8)
typedef int32_t psb_i_t; typedef int32_t psb_c_i_t;
typedef int64_t psb_l_t; typedef int64_t psb_c_l_t;
#elif defined(PSB_IPK8) && defined(PSB_LPK8) #elif defined(PSB_IPK8) && defined(PSB_LPK8)
typedef int64_t psb_i_t; typedef int64_t psb_c_i_t;
typedef int64_t psb_l_t; typedef int64_t psb_c_l_t;
#else #else
#endif #endif
typedef int64_t psb_e_t; typedef int64_t psb_c_e_t;
typedef float psb_s_t; typedef float psb_c_s_t;
typedef double psb_d_t; typedef double psb_c_d_t;
#ifdef __cplusplus #ifdef __cplusplus
typedef std::complex<float> psb_c_t; typedef std::complex<float> psb_c_c_t;
typedef std::complex<double> psb_z_t; typedef std::complex<double> psb_c_z_t;
#else #else
typedef float complex psb_c_t; typedef float complex psb_c_c_t;
typedef double complex psb_z_t; typedef double complex psb_c_z_t;
#endif #endif
#endif #endif

80
cbind/base/psb_c_base.h
Unescape Escape View File

@ -27,80 +27,80 @@ extern "C" {
typedef struct PSB_C_CTXT { typedef struct PSB_C_CTXT {
psb_i_t *ctxt; psb_c_i_t *ctxt;
} psb_c_ctxt; } psb_c_ctxt;
void psb_c_check_error(psb_c_ctxt cctxt); void psb_c_check_error(psb_c_ctxt cctxt);
psb_i_t psb_c_error(); psb_c_i_t psb_c_error();
psb_i_t psb_c_clean_errstack(); psb_c_i_t psb_c_clean_errstack();
void psb_c_print_errmsg(); void psb_c_print_errmsg();
char *psb_c_pop_errmsg(); char *psb_c_pop_errmsg();
psb_i_t psb_c_f2c_errmsg(char *, psb_i_t); psb_c_i_t psb_c_f2c_errmsg(char *, psb_c_i_t);
void psb_c_seterraction_ret(); void psb_c_seterraction_ret();
void psb_c_seterraction_print(); void psb_c_seterraction_print();
void psb_c_seterraction_abort(); void psb_c_seterraction_abort();
/* Environment routines */ /* Environment routines */
void psb_c_init(psb_c_ctxt *cctxt); void psb_c_init(psb_c_ctxt *cctxt);
void psb_c_init_from_fint(psb_c_ctxt *cctxt, psb_i_t f_comm); void psb_c_init_from_fint(psb_c_ctxt *cctxt, psb_c_i_t f_comm);
void psb_c_exit(psb_c_ctxt cctxt); void psb_c_exit(psb_c_ctxt cctxt);
void psb_c_exit_ctxt(psb_c_ctxt cctxt); void psb_c_exit_ctxt(psb_c_ctxt cctxt);
void psb_c_abort(psb_c_ctxt cctxt); void psb_c_abort(psb_c_ctxt cctxt);
void psb_c_barrier(psb_c_ctxt cctxt); void psb_c_barrier(psb_c_ctxt cctxt);
void psb_c_info(psb_c_ctxt cctxt, psb_i_t *iam, psb_i_t *np); void psb_c_info(psb_c_ctxt cctxt, psb_c_i_t *iam, psb_c_i_t *np);
void psb_c_get_i_ctxt(psb_c_ctxt cctxt, psb_i_t *ictxt, psb_i_t *info); void psb_c_get_i_ctxt(psb_c_ctxt cctxt, psb_c_i_t *ictxt, psb_c_i_t *info);
bool psb_c_cmp_ctxt(psb_c_ctxt cctxt1, psb_c_ctxt cctxt2); bool psb_c_cmp_ctxt(psb_c_ctxt cctxt1, psb_c_ctxt cctxt2);
psb_d_t psb_c_wtime(); psb_c_d_t psb_c_wtime();
psb_i_t psb_c_get_errstatus(); psb_c_i_t psb_c_get_errstatus();
psb_i_t psb_c_get_index_base(); psb_c_i_t psb_c_get_index_base();
void psb_c_set_index_base(psb_i_t base); void psb_c_set_index_base(psb_c_i_t base);
/* GPU environment routines */ /* GPU environment routines */
#ifdef PSB_HAVE_CUDA #ifdef PSB_HAVE_CUDA
void psb_c_cuda_init(psb_c_ctxt *cctxt); void psb_c_cuda_init(psb_c_ctxt *cctxt);
void psb_c_cuda_init_opt(psb_c_ctxt *cctxt, psb_m_t ngpu); void psb_c_cuda_init_opt(psb_c_ctxt *cctxt, psb_c_m_t ngpu);
void psb_c_cuda_exit(); void psb_c_cuda_exit();
psb_m_t psb_c_cuda_getDeviceCount(); psb_c_m_t psb_c_cuda_getDeviceCount();
#endif #endif
void psb_c_mbcast(psb_c_ctxt cctxt, psb_i_t n, psb_m_t *v, psb_i_t root); void psb_c_mbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_m_t *v, psb_c_i_t root);
void psb_c_ibcast(psb_c_ctxt cctxt, psb_i_t n, psb_i_t *v, psb_i_t root); void psb_c_ibcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_i_t *v, psb_c_i_t root);
void psb_c_lbcast(psb_c_ctxt cctxt, psb_i_t n, psb_l_t *v, psb_i_t root); void psb_c_lbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_l_t *v, psb_c_i_t root);
void psb_c_ebcast(psb_c_ctxt cctxt, psb_i_t n, psb_e_t *v, psb_i_t root); void psb_c_ebcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_e_t *v, psb_c_i_t root);
void psb_c_sbcast(psb_c_ctxt cctxt, psb_i_t n, psb_s_t *v, psb_i_t root); void psb_c_sbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_s_t *v, psb_c_i_t root);
void psb_c_dbcast(psb_c_ctxt cctxt, psb_i_t n, psb_d_t *v, psb_i_t root); void psb_c_dbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_d_t *v, psb_c_i_t root);
void psb_c_cbcast(psb_c_ctxt cctxt, psb_i_t n, psb_c_t *v, psb_i_t root); void psb_c_cbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_c_t *v, psb_c_i_t root);
void psb_c_zbcast(psb_c_ctxt cctxt, psb_i_t n, psb_z_t *v, psb_i_t root); void psb_c_zbcast(psb_c_ctxt cctxt, psb_c_i_t n, psb_c_z_t *v, psb_c_i_t root);
void psb_c_hbcast(psb_c_ctxt cctxt, const char *v, psb_i_t root); void psb_c_hbcast(psb_c_ctxt cctxt, const char *v, psb_c_i_t root);
/* Descriptor/integer routines */ /* Descriptor/integer routines */
psb_c_descriptor* psb_c_new_descriptor(); psb_c_descriptor* psb_c_new_descriptor();
void psb_c_delete_descriptor(psb_c_descriptor *); void psb_c_delete_descriptor(psb_c_descriptor *);
psb_c_ctxt* psb_c_new_ctxt(); psb_c_ctxt* psb_c_new_ctxt();
void psb_c_delete_ctxt(psb_c_ctxt *); void psb_c_delete_ctxt(psb_c_ctxt *);
psb_i_t psb_c_cdall_vg(psb_l_t ng, psb_i_t *vg, psb_c_ctxt cctxt, psb_c_descriptor *cd); psb_c_i_t psb_c_cdall_vg(psb_c_l_t ng, psb_c_i_t *vg, psb_c_ctxt cctxt, psb_c_descriptor *cd);
psb_i_t psb_c_cdall_vl(psb_i_t nl, psb_l_t *vl, psb_c_ctxt cctxt, psb_c_descriptor *cd); psb_c_i_t psb_c_cdall_vl(psb_c_i_t nl, psb_c_l_t *vl, psb_c_ctxt cctxt, psb_c_descriptor *cd);
psb_i_t psb_c_cdall_vl_lidx(psb_i_t nl, psb_l_t *vl, psb_i_t *lidx, psb_c_ctxt cctxt, psb_c_descriptor *cd); psb_c_i_t psb_c_cdall_vl_lidx(psb_c_i_t nl, psb_c_l_t *vl, psb_c_i_t *lidx, psb_c_ctxt cctxt, psb_c_descriptor *cd);
psb_i_t psb_c_cdall_nl(psb_i_t nl, psb_c_ctxt cctxt, psb_c_descriptor *cd); psb_c_i_t psb_c_cdall_nl(psb_c_i_t nl, psb_c_ctxt cctxt, psb_c_descriptor *cd);
psb_i_t psb_c_cdall_repl(psb_l_t n, psb_c_ctxt cctxt, psb_c_descriptor *cd); psb_c_i_t psb_c_cdall_repl(psb_c_l_t n, psb_c_ctxt cctxt, psb_c_descriptor *cd);
psb_i_t psb_c_cdasb(psb_c_descriptor *cd); psb_c_i_t psb_c_cdasb(psb_c_descriptor *cd);
psb_i_t psb_c_cdasb_format(psb_c_descriptor *cd, const char *afmt); psb_c_i_t psb_c_cdasb_format(psb_c_descriptor *cd, const char *afmt);
psb_i_t psb_c_cdfree(psb_c_descriptor *cd); psb_c_i_t psb_c_cdfree(psb_c_descriptor *cd);
psb_i_t psb_c_cdins(psb_i_t nz, const psb_l_t *ia, const psb_l_t *ja, psb_c_descriptor *cd); psb_c_i_t psb_c_cdins(psb_c_i_t nz, const psb_c_l_t *ia, const psb_c_l_t *ja, psb_c_descriptor *cd);
psb_i_t psb_c_cdins_lidx(psb_i_t nz, const psb_l_t *ja, const psb_i_t *lidx, psb_c_descriptor *cd); psb_c_i_t psb_c_cdins_lidx(psb_c_i_t nz, const psb_c_l_t *ja, const psb_c_i_t *lidx, psb_c_descriptor *cd);
bool psb_c_is_owned(psb_l_t gindex, psb_c_descriptor *cd); bool psb_c_is_owned(psb_c_l_t gindex, psb_c_descriptor *cd);
bool psb_c_cd_is_asb(psb_c_descriptor *cd); bool psb_c_cd_is_asb(psb_c_descriptor *cd);
psb_i_t psb_c_cd_check_addr(psb_c_descriptor *cd); psb_c_i_t psb_c_cd_check_addr(psb_c_descriptor *cd);
psb_i_t psb_c_cd_get_local_rows(psb_c_descriptor *cd); psb_c_i_t psb_c_cd_get_local_rows(psb_c_descriptor *cd);
psb_i_t psb_c_cd_get_local_cols(psb_c_descriptor *cd); psb_c_i_t psb_c_cd_get_local_cols(psb_c_descriptor *cd);
psb_l_t psb_c_cd_get_global_rows(psb_c_descriptor *cd); psb_c_l_t psb_c_cd_get_global_rows(psb_c_descriptor *cd);
psb_l_t psb_c_cd_get_global_cols(psb_c_descriptor *cd); psb_c_l_t psb_c_cd_get_global_cols(psb_c_descriptor *cd);
psb_i_t psb_c_cd_get_global_indices(psb_l_t idx[], psb_i_t nidx, bool owned, psb_c_descriptor *cd); psb_c_i_t psb_c_cd_get_global_indices(psb_c_l_t idx[], psb_c_i_t nidx, bool owned, psb_c_descriptor *cd);
psb_i_t psb_c_g2l(psb_c_descriptor *cdh,psb_l_t gindex,bool cowned); psb_c_i_t psb_c_g2l(psb_c_descriptor *cdh,psb_c_l_t gindex,bool cowned);

8
cbind/base/psb_c_cbase.c
Unescape Escape View File

@ -10,10 +10,10 @@ psb_c_cvector* psb_c_new_cvector()
return(temp); return(temp);
} }
psb_c_t* psb_c_cvect_get_cpy(psb_c_cvector *xh) psb_c_c_t* psb_c_cvect_get_cpy(psb_c_cvector *xh)
{ {
psb_c_t *temp=NULL; psb_c_c_t *temp=NULL;
psb_i_t vsize=0; psb_c_i_t vsize=0;
if ((vsize=psb_c_cvect_get_nrows(xh))<0) if ((vsize=psb_c_cvect_get_nrows(xh))<0)
return(temp); return(temp);
@ -21,7 +21,7 @@ psb_c_t* psb_c_cvect_get_cpy(psb_c_cvector *xh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_c_t *)malloc(vsize*sizeof(psb_c_t)))!=NULL) if ((temp=(psb_c_c_t *)malloc(vsize*sizeof(psb_c_c_t)))!=NULL)
psb_c_cvect_f_get_cpy(temp,xh); psb_c_cvect_f_get_cpy(temp,xh);
return(temp); return(temp);

160
cbind/base/psb_c_cbase.h
Unescape Escape View File

@ -17,103 +17,103 @@ typedef struct PSB_C_CSPMAT {
/* dense vectors */ /* dense vectors */
psb_c_cvector* psb_c_new_cvector(); psb_c_cvector* psb_c_new_cvector();
psb_i_t psb_c_cvect_get_nrows(psb_c_cvector *xh); psb_c_i_t psb_c_cvect_get_nrows(psb_c_cvector *xh);
psb_c_t *psb_c_cvect_get_cpy(psb_c_cvector *xh); psb_c_c_t *psb_c_cvect_get_cpy(psb_c_cvector *xh);
psb_i_t psb_c_cvect_f_get_cpy(psb_c_t *v, psb_c_cvector *xh); psb_c_i_t psb_c_cvect_f_get_cpy(psb_c_c_t *v, psb_c_cvector *xh);
psb_i_t psb_c_cvect_zero(psb_c_cvector *xh); psb_c_i_t psb_c_cvect_zero(psb_c_cvector *xh);
psb_c_t *psb_c_cvect_f_get_pnt(psb_c_cvector *xh); psb_c_c_t *psb_c_cvect_f_get_pnt(psb_c_cvector *xh);
psb_i_t psb_c_cvect_clone(psb_c_cvector *xh, psb_c_cvector *yh); psb_c_i_t psb_c_cvect_clone(psb_c_cvector *xh, psb_c_cvector *yh);
psb_i_t psb_c_cgeall(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeall(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeall_remote(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeall_remote(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeall_remote_options(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_cgeall_remote_options(psb_c_cvector *xh, psb_c_descriptor *cdh,
psb_i_t bldmode, psb_i_t dupl); psb_c_i_t bldmode, psb_c_i_t dupl);
psb_i_t psb_c_cgeins(psb_i_t nz, const psb_l_t *irw, const psb_c_t *val, psb_c_i_t psb_c_cgeins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_c_t *val,
psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeins_add(psb_i_t nz, const psb_l_t *irw, const psb_c_t *val, psb_c_i_t psb_c_cgeins_add(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_c_t *val,
psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeasb(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeasb(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeasb_options(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_i_t dupl); psb_c_i_t psb_c_cgeasb_options(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_c_i_t dupl);
psb_i_t psb_c_cgeasb_options_format(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_cgeasb_options_format(psb_c_cvector *xh, psb_c_descriptor *cdh,
psb_i_t dupl, const char *fmt); psb_c_i_t dupl, const char *fmt);
psb_i_t psb_c_cgefree(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgefree(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgereinit(psb_c_cvector *xh, psb_c_descriptor *cdh, bool clear); psb_c_i_t psb_c_cgereinit(psb_c_cvector *xh, psb_c_descriptor *cdh, bool clear);
psb_c_t psb_c_cgetelem(psb_c_cvector *xh,psb_l_t index,psb_c_descriptor *cd); psb_c_c_t psb_c_cgetelem(psb_c_cvector *xh,psb_c_l_t index,psb_c_descriptor *cd);
psb_c_t psb_c_cmatgetelem(psb_c_cspmat *ah,psb_l_t rowindex,psb_l_t colindex,psb_c_descriptor *cdh); psb_c_c_t psb_c_cmatgetelem(psb_c_cspmat *ah,psb_c_l_t rowindex,psb_c_l_t colindex,psb_c_descriptor *cdh);
psb_i_t psb_c_csetelem(psb_l_t index, psb_c_t val, psb_c_i_t psb_c_csetelem(psb_c_l_t index, psb_c_c_t val,
psb_c_cvector *xh, psb_c_descriptor *cd); psb_c_cvector *xh, psb_c_descriptor *cd);
/* sparse matrices*/ /* sparse matrices*/
psb_c_cspmat* psb_c_new_cspmat(); psb_c_cspmat* psb_c_new_cspmat();
psb_i_t psb_c_cspall(psb_c_cspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspall(psb_c_cspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspall_remote(psb_c_cspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspall_remote(psb_c_cspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspasb(psb_c_cspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspasb(psb_c_cspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspfree(psb_c_cspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspfree(psb_c_cspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspins(psb_i_t nz, const psb_l_t *irw, const psb_l_t *icl, psb_c_i_t psb_c_cspins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_l_t *icl,
const psb_c_t *val, psb_c_cspmat *mh, psb_c_descriptor *cdh); const psb_c_c_t *val, psb_c_cspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_cmat_get_nrows(psb_c_cspmat *mh); psb_c_i_t psb_c_cmat_get_nrows(psb_c_cspmat *mh);
psb_i_t psb_c_cmat_get_ncols(psb_c_cspmat *mh); psb_c_i_t psb_c_cmat_get_ncols(psb_c_cspmat *mh);
psb_l_t psb_c_cnnz(psb_c_cspmat *mh,psb_c_descriptor *cdh); psb_c_l_t psb_c_cnnz(psb_c_cspmat *mh,psb_c_descriptor *cdh);
bool psb_c_cis_matupd(psb_c_cspmat *mh,psb_c_descriptor *cdh); bool psb_c_cis_matupd(psb_c_cspmat *mh,psb_c_descriptor *cdh);
bool psb_c_cis_matasb(psb_c_cspmat *mh,psb_c_descriptor *cdh); bool psb_c_cis_matasb(psb_c_cspmat *mh,psb_c_descriptor *cdh);
bool psb_c_cis_matbld(psb_c_cspmat *mh,psb_c_descriptor *cdh); bool psb_c_cis_matbld(psb_c_cspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_cset_matupd(psb_c_cspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cset_matupd(psb_c_cspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_cset_matasb(psb_c_cspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cset_matasb(psb_c_cspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_cset_matbld(psb_c_cspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cset_matbld(psb_c_cspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_ccopy_mat(psb_c_cspmat *ah,psb_c_cspmat *bh,psb_c_descriptor *cdh); psb_c_i_t psb_c_ccopy_mat(psb_c_cspmat *ah,psb_c_cspmat *bh,psb_c_descriptor *cdh);
/* psb_i_t psb_c_cspasb_opt(psb_c_cspmat *mh, psb_c_descriptor *cdh, */ /* psb_c_i_t psb_c_cspasb_opt(psb_c_cspmat *mh, psb_c_descriptor *cdh, */
/* const char *afmt, psb_i_t upd, psb_i_t dupl); */ /* const char *afmt, psb_c_i_t upd, psb_c_i_t dupl); */
psb_i_t psb_c_csprn(psb_c_cspmat *mh, psb_c_descriptor *cdh, _Bool clear); psb_c_i_t psb_c_csprn(psb_c_cspmat *mh, psb_c_descriptor *cdh, _Bool clear);
psb_i_t psb_c_cmat_name_print(psb_c_cspmat *mh, char *name); psb_c_i_t psb_c_cmat_name_print(psb_c_cspmat *mh, char *name);
psb_i_t psb_c_cvect_set_scal(psb_c_cvector *xh, psb_c_t val); psb_c_i_t psb_c_cvect_set_scal(psb_c_cvector *xh, psb_c_c_t val);
psb_i_t psb_c_cvect_set_scal_bound(psb_c_cvector *xh, psb_c_t val, psb_c_i_t psb_c_cvect_set_scal_bound(psb_c_cvector *xh, psb_c_c_t val,
psb_i_t ifirst, psb_i_t ilast); psb_c_i_t ifirst, psb_c_i_t ilast);
psb_i_t psb_c_cvect_set_vect(psb_c_cvector *xh, psb_c_t *val, psb_i_t n); psb_c_i_t psb_c_cvect_set_vect(psb_c_cvector *xh, psb_c_c_t *val, psb_c_i_t n);
psb_c_t psb_c_cvect_get_entry(psb_c_cvector *xh, psb_i_t index); psb_c_c_t psb_c_cvect_get_entry(psb_c_cvector *xh, psb_c_i_t index);
psb_i_t psb_c_cvect_set_entry(psb_c_cvector *xh, psb_i_t index, psb_c_t val); psb_c_i_t psb_c_cvect_set_entry(psb_c_cvector *xh, psb_c_i_t index, psb_c_c_t val);
/* psblas computational routines */ /* psblas computational routines */
psb_c_t psb_c_cgedot(psb_c_cvector *xh, psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_c_t psb_c_cgedot(psb_c_cvector *xh, psb_c_cvector *yh, psb_c_descriptor *cdh);
psb_s_t psb_c_cgenrm2(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_cgenrm2(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_cgeamax(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_cgeamax(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_cgeasum(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_cgeasum(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_cgenrmi(psb_c_cvector *ah, psb_c_descriptor *cdh); psb_c_s_t psb_c_cgenrmi(psb_c_cvector *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeaxpby(psb_c_t alpha, psb_c_cvector *xh, psb_c_i_t psb_c_cgeaxpby(psb_c_c_t alpha, psb_c_cvector *xh,
psb_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgeaxpbyz(psb_c_t alpha, psb_c_cvector *xh, psb_c_i_t psb_c_cgeaxpbyz(psb_c_c_t alpha, psb_c_cvector *xh,
psb_c_t beta, psb_c_cvector *yh, psb_c_cvector *zh, psb_c_descriptor *cdh); psb_c_c_t beta, psb_c_cvector *yh, psb_c_cvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspmm(psb_c_t alpha, psb_c_cspmat *ah, psb_c_cvector *xh, psb_c_i_t psb_c_cspmm(psb_c_c_t alpha, psb_c_cspmat *ah, psb_c_cvector *xh,
psb_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspmm_opt(psb_c_t alpha, psb_c_cspmat *ah, psb_c_cvector *xh, psb_c_i_t psb_c_cspmm_opt(psb_c_c_t alpha, psb_c_cspmat *ah, psb_c_cvector *xh,
psb_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh, psb_c_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh,
char *trans, bool doswap); char *trans, bool doswap);
psb_i_t psb_c_cspsm(psb_c_t alpha, psb_c_cspmat *th, psb_c_cvector *xh, psb_c_i_t psb_c_cspsm(psb_c_c_t alpha, psb_c_cspmat *th, psb_c_cvector *xh,
psb_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_c_t beta, psb_c_cvector *yh, psb_c_descriptor *cdh);
/* Additional computational routines */ /* Additional computational routines */
psb_i_t psb_c_cgemlt(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgemlt(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_cgemlt2(psb_c_t alpha, psb_c_cvector *xh, psb_c_cvector *yh, psb_c_t beta, psb_c_cvector *zh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgemlt2(psb_c_c_t alpha, psb_c_cvector *xh, psb_c_cvector *yh, psb_c_c_t beta, psb_c_cvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgediv(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgediv(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_cgediv_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_cgediv_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_cgediv2(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_cvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgediv2(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_cvector *zh,psb_c_descriptor *cdh);
psb_i_t psb_c_cgediv2_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_cvector *zh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_cgediv2_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_cvector *zh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_cgeinv(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeinv(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_cgeinv_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_cgeinv_check(psb_c_cvector *xh,psb_c_cvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_cgeabs(psb_c_cvector *xh,psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeabs(psb_c_cvector *xh,psb_c_cvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_cgecmp(psb_c_cvector *xh,psb_s_t ch,psb_c_cvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgecmp(psb_c_cvector *xh,psb_c_s_t ch,psb_c_cvector *zh,psb_c_descriptor *cdh);
bool psb_c_cgecmpmat(psb_c_cspmat *ah,psb_c_cspmat *bh,psb_s_t tol,psb_c_descriptor *cdh); bool psb_c_cgecmpmat(psb_c_cspmat *ah,psb_c_cspmat *bh,psb_c_s_t tol,psb_c_descriptor *cdh);
bool psb_c_cgecmpmat_val(psb_c_cspmat *ah,psb_c_t val,psb_s_t tol,psb_c_descriptor *cdh); bool psb_c_cgecmpmat_val(psb_c_cspmat *ah,psb_c_c_t val,psb_c_s_t tol,psb_c_descriptor *cdh);
psb_i_t psb_c_cgeaddconst(psb_c_cvector *xh,psb_c_t bh,psb_c_cvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cgeaddconst(psb_c_cvector *xh,psb_c_c_t bh,psb_c_cvector *zh,psb_c_descriptor *cdh);
psb_s_t psb_c_cgenrm2_weight(psb_c_cvector *xh,psb_c_cvector *wh,psb_c_descriptor *cdh); psb_c_s_t psb_c_cgenrm2_weight(psb_c_cvector *xh,psb_c_cvector *wh,psb_c_descriptor *cdh);
psb_s_t psb_c_cgenrm2_weightmask(psb_c_cvector *xh,psb_c_cvector *wh,psb_c_cvector *idvh,psb_c_descriptor *cdh); psb_c_s_t psb_c_cgenrm2_weightmask(psb_c_cvector *xh,psb_c_cvector *wh,psb_c_cvector *idvh,psb_c_descriptor *cdh);
psb_i_t psb_c_cmask(psb_c_cvector *ch,psb_c_cvector *xh,psb_c_cvector *mh, bool *t, psb_c_descriptor *cdh); psb_c_i_t psb_c_cmask(psb_c_cvector *ch,psb_c_cvector *xh,psb_c_cvector *mh, bool *t, psb_c_descriptor *cdh);
psb_c_t psb_c_cgemin(psb_c_cvector *xh,psb_c_descriptor *cdh); psb_c_c_t psb_c_cgemin(psb_c_cvector *xh,psb_c_descriptor *cdh);
psb_c_t psb_c_cminquotient(psb_c_cvector *xh,psb_c_cvector *yh, psb_c_descriptor *cdh); psb_c_c_t psb_c_cminquotient(psb_c_cvector *xh,psb_c_cvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspscal(psb_c_t alpha, psb_c_cspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspscal(psb_c_c_t alpha, psb_c_cspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_cspscalpid(psb_c_t alpha, psb_c_cspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspscalpid(psb_c_c_t alpha, psb_c_cspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_cspaxpby(psb_c_t alpha, psb_c_cspmat *ah, psb_c_t beta, psb_c_cspmat *bh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cspaxpby(psb_c_c_t alpha, psb_c_cspmat *ah, psb_c_c_t beta, psb_c_cspmat *bh, psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
cbind/base/psb_c_ccomm.c
Unescape Escape View File

@ -3,10 +3,10 @@
#include "psb_c_cbase.h" #include "psb_c_cbase.h"
psb_c_t* psb_c_cvgather(psb_c_cvector *xh, psb_c_descriptor *cdh) psb_c_c_t* psb_c_cvgather(psb_c_cvector *xh, psb_c_descriptor *cdh)
{ {
psb_c_t *temp=NULL; psb_c_c_t *temp=NULL;
psb_l_t vsize=0; psb_c_l_t vsize=0;
if ((vsize=psb_c_cd_get_global_rows(cdh))<0) if ((vsize=psb_c_cd_get_global_rows(cdh))<0)
return(temp); return(temp);
@ -14,7 +14,7 @@ psb_c_t* psb_c_cvgather(psb_c_cvector *xh, psb_c_descriptor *cdh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_c_t *)malloc(vsize*sizeof(psb_c_t)))!=NULL) if ((temp=(psb_c_c_t *)malloc(vsize*sizeof(psb_c_c_t)))!=NULL)
psb_c_cvgather_f(temp,xh,cdh); psb_c_cvgather_f(temp,xh,cdh);
return(temp); return(temp);

20
cbind/base/psb_c_ccomm.h
Unescape Escape View File

@ -6,20 +6,20 @@
extern "C" { extern "C" {
#endif #endif
psb_i_t psb_c_chalo(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_chalo(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_chalo_opt(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_chalo_opt(psb_c_cvector *xh, psb_c_descriptor *cdh,
char *trans, psb_i_t mode); char *trans, psb_c_i_t mode);
psb_i_t psb_c_covrl(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_covrl(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_covrl_opt(psb_c_cvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_covrl_opt(psb_c_cvector *xh, psb_c_descriptor *cdh,
psb_i_t update, psb_i_t mode); psb_c_i_t update, psb_c_i_t mode);
psb_i_t psb_c_cvscatter(psb_l_t ng, psb_c_t *gx, psb_c_cvector *xh, psb_c_i_t psb_c_cvscatter(psb_c_l_t ng, psb_c_c_t *gx, psb_c_cvector *xh,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);
psb_c_t* psb_c_cvgather(psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_c_t* psb_c_cvgather(psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_c_cspmat* psb_c_cspgather(psb_c_cspmat *ah, psb_c_descriptor *cdh); psb_c_cspmat* psb_c_cspgather(psb_c_cspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_cvgather_f(psb_c_t* gv, psb_c_cvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_cvgather_f(psb_c_c_t* gv, psb_c_cvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_cspgather_f(psb_c_cspmat* ga, psb_c_cspmat *ah, psb_c_i_t psb_c_cspgather_f(psb_c_cspmat* ga, psb_c_cspmat *ah,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);

8
cbind/base/psb_c_dbase.c
Unescape Escape View File

@ -10,10 +10,10 @@ psb_c_dvector* psb_c_new_dvector()
return(temp); return(temp);
} }
psb_d_t* psb_c_dvect_get_cpy(psb_c_dvector *xh) psb_c_d_t* psb_c_dvect_get_cpy(psb_c_dvector *xh)
{ {
psb_d_t *temp=NULL; psb_c_d_t *temp=NULL;
psb_i_t vsize=0; psb_c_i_t vsize=0;
if ((vsize=psb_c_dvect_get_nrows(xh))<0) if ((vsize=psb_c_dvect_get_nrows(xh))<0)
return(temp); return(temp);
@ -21,7 +21,7 @@ psb_d_t* psb_c_dvect_get_cpy(psb_c_dvector *xh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_d_t *)malloc(vsize*sizeof(psb_d_t)))!=NULL) if ((temp=(psb_c_d_t *)malloc(vsize*sizeof(psb_c_d_t)))!=NULL)
psb_c_dvect_f_get_cpy(temp,xh); psb_c_dvect_f_get_cpy(temp,xh);
return(temp); return(temp);

160
cbind/base/psb_c_dbase.h
Unescape Escape View File

@ -17,103 +17,103 @@ typedef struct PSB_C_DSPMAT {
/* dense vectors */ /* dense vectors */
psb_c_dvector* psb_c_new_dvector(); psb_c_dvector* psb_c_new_dvector();
psb_i_t psb_c_dvect_get_nrows(psb_c_dvector *xh); psb_c_i_t psb_c_dvect_get_nrows(psb_c_dvector *xh);
psb_d_t *psb_c_dvect_get_cpy(psb_c_dvector *xh); psb_c_d_t *psb_c_dvect_get_cpy(psb_c_dvector *xh);
psb_i_t psb_c_dvect_f_get_cpy(psb_d_t *v, psb_c_dvector *xh); psb_c_i_t psb_c_dvect_f_get_cpy(psb_c_d_t *v, psb_c_dvector *xh);
psb_i_t psb_c_dvect_zero(psb_c_dvector *xh); psb_c_i_t psb_c_dvect_zero(psb_c_dvector *xh);
psb_d_t *psb_c_dvect_f_get_pnt(psb_c_dvector *xh); psb_c_d_t *psb_c_dvect_f_get_pnt(psb_c_dvector *xh);
psb_i_t psb_c_dvect_clone(psb_c_dvector *xh, psb_c_dvector *yh); psb_c_i_t psb_c_dvect_clone(psb_c_dvector *xh, psb_c_dvector *yh);
psb_i_t psb_c_dgeall(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeall(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeall_remote(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeall_remote(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeall_remote_options(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_dgeall_remote_options(psb_c_dvector *xh, psb_c_descriptor *cdh,
psb_i_t bldmode, psb_i_t dupl); psb_c_i_t bldmode, psb_c_i_t dupl);
psb_i_t psb_c_dgeins(psb_i_t nz, const psb_l_t *irw, const psb_d_t *val, psb_c_i_t psb_c_dgeins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_d_t *val,
psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeins_add(psb_i_t nz, const psb_l_t *irw, const psb_d_t *val, psb_c_i_t psb_c_dgeins_add(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_d_t *val,
psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeasb(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeasb(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeasb_options(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_i_t dupl); psb_c_i_t psb_c_dgeasb_options(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_c_i_t dupl);
psb_i_t psb_c_dgeasb_options_format(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_dgeasb_options_format(psb_c_dvector *xh, psb_c_descriptor *cdh,
psb_i_t dupl, const char *fmt); psb_c_i_t dupl, const char *fmt);
psb_i_t psb_c_dgefree(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgefree(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgereinit(psb_c_dvector *xh, psb_c_descriptor *cdh, bool clear); psb_c_i_t psb_c_dgereinit(psb_c_dvector *xh, psb_c_descriptor *cdh, bool clear);
psb_d_t psb_c_dgetelem(psb_c_dvector *xh,psb_l_t index,psb_c_descriptor *cd); psb_c_d_t psb_c_dgetelem(psb_c_dvector *xh,psb_c_l_t index,psb_c_descriptor *cd);
psb_d_t psb_c_dmatgetelem(psb_c_dspmat *ah,psb_l_t rowindex,psb_l_t colindex,psb_c_descriptor *cdh); psb_c_d_t psb_c_dmatgetelem(psb_c_dspmat *ah,psb_c_l_t rowindex,psb_c_l_t colindex,psb_c_descriptor *cdh);
psb_i_t psb_c_dsetelem(psb_l_t index, psb_d_t val, psb_c_i_t psb_c_dsetelem(psb_c_l_t index, psb_c_d_t val,
psb_c_dvector *xh, psb_c_descriptor *cd); psb_c_dvector *xh, psb_c_descriptor *cd);
/* sparse matrices*/ /* sparse matrices*/
psb_c_dspmat* psb_c_new_dspmat(); psb_c_dspmat* psb_c_new_dspmat();
psb_i_t psb_c_dspall(psb_c_dspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspall(psb_c_dspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspall_remote(psb_c_dspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspall_remote(psb_c_dspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspasb(psb_c_dspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspasb(psb_c_dspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspfree(psb_c_dspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspfree(psb_c_dspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspins(psb_i_t nz, const psb_l_t *irw, const psb_l_t *icl, psb_c_i_t psb_c_dspins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_l_t *icl,
const psb_d_t *val, psb_c_dspmat *mh, psb_c_descriptor *cdh); const psb_c_d_t *val, psb_c_dspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_dmat_get_nrows(psb_c_dspmat *mh); psb_c_i_t psb_c_dmat_get_nrows(psb_c_dspmat *mh);
psb_i_t psb_c_dmat_get_ncols(psb_c_dspmat *mh); psb_c_i_t psb_c_dmat_get_ncols(psb_c_dspmat *mh);
psb_l_t psb_c_dnnz(psb_c_dspmat *mh,psb_c_descriptor *cdh); psb_c_l_t psb_c_dnnz(psb_c_dspmat *mh,psb_c_descriptor *cdh);
bool psb_c_dis_matupd(psb_c_dspmat *mh,psb_c_descriptor *cdh); bool psb_c_dis_matupd(psb_c_dspmat *mh,psb_c_descriptor *cdh);
bool psb_c_dis_matasb(psb_c_dspmat *mh,psb_c_descriptor *cdh); bool psb_c_dis_matasb(psb_c_dspmat *mh,psb_c_descriptor *cdh);
bool psb_c_dis_matbld(psb_c_dspmat *mh,psb_c_descriptor *cdh); bool psb_c_dis_matbld(psb_c_dspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_dset_matupd(psb_c_dspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dset_matupd(psb_c_dspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_dset_matasb(psb_c_dspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dset_matasb(psb_c_dspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_dset_matbld(psb_c_dspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dset_matbld(psb_c_dspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_dcopy_mat(psb_c_dspmat *ah,psb_c_dspmat *bh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dcopy_mat(psb_c_dspmat *ah,psb_c_dspmat *bh,psb_c_descriptor *cdh);
/* psb_i_t psb_c_dspasb_opt(psb_c_dspmat *mh, psb_c_descriptor *cdh, */ /* psb_c_i_t psb_c_dspasb_opt(psb_c_dspmat *mh, psb_c_descriptor *cdh, */
/* const char *afmt, psb_i_t upd, psb_i_t dupl); */ /* const char *afmt, psb_c_i_t upd, psb_c_i_t dupl); */
psb_i_t psb_c_dsprn(psb_c_dspmat *mh, psb_c_descriptor *cdh, _Bool clear); psb_c_i_t psb_c_dsprn(psb_c_dspmat *mh, psb_c_descriptor *cdh, _Bool clear);
psb_i_t psb_c_dmat_name_print(psb_c_dspmat *mh, char *name); psb_c_i_t psb_c_dmat_name_print(psb_c_dspmat *mh, char *name);
psb_i_t psb_c_dvect_set_scal(psb_c_dvector *xh, psb_d_t val); psb_c_i_t psb_c_dvect_set_scal(psb_c_dvector *xh, psb_c_d_t val);
psb_i_t psb_c_dvect_set_scal_bound(psb_c_dvector *xh, psb_d_t val, psb_c_i_t psb_c_dvect_set_scal_bound(psb_c_dvector *xh, psb_c_d_t val,
psb_i_t ifirst, psb_i_t ilast); psb_c_i_t ifirst, psb_c_i_t ilast);
psb_i_t psb_c_dvect_set_vect(psb_c_dvector *xh, psb_d_t *val, psb_i_t n); psb_c_i_t psb_c_dvect_set_vect(psb_c_dvector *xh, psb_c_d_t *val, psb_c_i_t n);
psb_d_t psb_c_dvect_get_entry(psb_c_dvector *xh, psb_i_t index); psb_c_d_t psb_c_dvect_get_entry(psb_c_dvector *xh, psb_c_i_t index);
psb_i_t psb_c_dvect_set_entry(psb_c_dvector *xh, psb_i_t index, psb_d_t val); psb_c_i_t psb_c_dvect_set_entry(psb_c_dvector *xh, psb_c_i_t index, psb_c_d_t val);
/* psblas computational routines */ /* psblas computational routines */
psb_d_t psb_c_dgedot(psb_c_dvector *xh, psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_d_t psb_c_dgedot(psb_c_dvector *xh, psb_c_dvector *yh, psb_c_descriptor *cdh);
psb_d_t psb_c_dgenrm2(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_dgenrm2(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_dgeamax(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_dgeamax(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_dgeasum(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_dgeasum(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_dgenrmi(psb_c_dvector *ah, psb_c_descriptor *cdh); psb_c_d_t psb_c_dgenrmi(psb_c_dvector *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeaxpby(psb_d_t alpha, psb_c_dvector *xh, psb_c_i_t psb_c_dgeaxpby(psb_c_d_t alpha, psb_c_dvector *xh,
psb_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgeaxpbyz(psb_d_t alpha, psb_c_dvector *xh, psb_c_i_t psb_c_dgeaxpbyz(psb_c_d_t alpha, psb_c_dvector *xh,
psb_d_t beta, psb_c_dvector *yh, psb_c_dvector *zh, psb_c_descriptor *cdh); psb_c_d_t beta, psb_c_dvector *yh, psb_c_dvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspmm(psb_d_t alpha, psb_c_dspmat *ah, psb_c_dvector *xh, psb_c_i_t psb_c_dspmm(psb_c_d_t alpha, psb_c_dspmat *ah, psb_c_dvector *xh,
psb_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspmm_opt(psb_d_t alpha, psb_c_dspmat *ah, psb_c_dvector *xh, psb_c_i_t psb_c_dspmm_opt(psb_c_d_t alpha, psb_c_dspmat *ah, psb_c_dvector *xh,
psb_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh, psb_c_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh,
char *trans, bool doswap); char *trans, bool doswap);
psb_i_t psb_c_dspsm(psb_d_t alpha, psb_c_dspmat *th, psb_c_dvector *xh, psb_c_i_t psb_c_dspsm(psb_c_d_t alpha, psb_c_dspmat *th, psb_c_dvector *xh,
psb_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_d_t beta, psb_c_dvector *yh, psb_c_descriptor *cdh);
/* Additional computational routines */ /* Additional computational routines */
psb_i_t psb_c_dgemlt(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgemlt(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_dgemlt2(psb_d_t alpha, psb_c_dvector *xh, psb_c_dvector *yh, psb_d_t beta, psb_c_dvector *zh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgemlt2(psb_c_d_t alpha, psb_c_dvector *xh, psb_c_dvector *yh, psb_c_d_t beta, psb_c_dvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgediv(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgediv(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_dgediv_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_dgediv_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_dgediv2(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_dvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgediv2(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_dvector *zh,psb_c_descriptor *cdh);
psb_i_t psb_c_dgediv2_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_dvector *zh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_dgediv2_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_dvector *zh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_dgeinv(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeinv(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_dgeinv_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_dgeinv_check(psb_c_dvector *xh,psb_c_dvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_dgeabs(psb_c_dvector *xh,psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeabs(psb_c_dvector *xh,psb_c_dvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_dgecmp(psb_c_dvector *xh,psb_d_t ch,psb_c_dvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgecmp(psb_c_dvector *xh,psb_c_d_t ch,psb_c_dvector *zh,psb_c_descriptor *cdh);
bool psb_c_dgecmpmat(psb_c_dspmat *ah,psb_c_dspmat *bh,psb_d_t tol,psb_c_descriptor *cdh); bool psb_c_dgecmpmat(psb_c_dspmat *ah,psb_c_dspmat *bh,psb_c_d_t tol,psb_c_descriptor *cdh);
bool psb_c_dgecmpmat_val(psb_c_dspmat *ah,psb_d_t val,psb_d_t tol,psb_c_descriptor *cdh); bool psb_c_dgecmpmat_val(psb_c_dspmat *ah,psb_c_d_t val,psb_c_d_t tol,psb_c_descriptor *cdh);
psb_i_t psb_c_dgeaddconst(psb_c_dvector *xh,psb_d_t bh,psb_c_dvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dgeaddconst(psb_c_dvector *xh,psb_c_d_t bh,psb_c_dvector *zh,psb_c_descriptor *cdh);
psb_d_t psb_c_dgenrm2_weight(psb_c_dvector *xh,psb_c_dvector *wh,psb_c_descriptor *cdh); psb_c_d_t psb_c_dgenrm2_weight(psb_c_dvector *xh,psb_c_dvector *wh,psb_c_descriptor *cdh);
psb_d_t psb_c_dgenrm2_weightmask(psb_c_dvector *xh,psb_c_dvector *wh,psb_c_dvector *idvh,psb_c_descriptor *cdh); psb_c_d_t psb_c_dgenrm2_weightmask(psb_c_dvector *xh,psb_c_dvector *wh,psb_c_dvector *idvh,psb_c_descriptor *cdh);
psb_i_t psb_c_dmask(psb_c_dvector *ch,psb_c_dvector *xh,psb_c_dvector *mh, bool *t, psb_c_descriptor *cdh); psb_c_i_t psb_c_dmask(psb_c_dvector *ch,psb_c_dvector *xh,psb_c_dvector *mh, bool *t, psb_c_descriptor *cdh);
psb_d_t psb_c_dgemin(psb_c_dvector *xh,psb_c_descriptor *cdh); psb_c_d_t psb_c_dgemin(psb_c_dvector *xh,psb_c_descriptor *cdh);
psb_d_t psb_c_dminquotient(psb_c_dvector *xh,psb_c_dvector *yh, psb_c_descriptor *cdh); psb_c_d_t psb_c_dminquotient(psb_c_dvector *xh,psb_c_dvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspscal(psb_d_t alpha, psb_c_dspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspscal(psb_c_d_t alpha, psb_c_dspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_dspscalpid(psb_d_t alpha, psb_c_dspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspscalpid(psb_c_d_t alpha, psb_c_dspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_dspaxpby(psb_d_t alpha, psb_c_dspmat *ah, psb_d_t beta, psb_c_dspmat *bh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dspaxpby(psb_c_d_t alpha, psb_c_dspmat *ah, psb_c_d_t beta, psb_c_dspmat *bh, psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
cbind/base/psb_c_dcomm.c
Unescape Escape View File

@ -3,10 +3,10 @@
#include "psb_c_dbase.h" #include "psb_c_dbase.h"
psb_d_t* psb_c_dvgather(psb_c_dvector *xh, psb_c_descriptor *cdh) psb_c_d_t* psb_c_dvgather(psb_c_dvector *xh, psb_c_descriptor *cdh)
{ {
psb_d_t *temp=NULL; psb_c_d_t *temp=NULL;
psb_l_t vsize=0; psb_c_l_t vsize=0;
if ((vsize=psb_c_cd_get_global_rows(cdh))<0) if ((vsize=psb_c_cd_get_global_rows(cdh))<0)
return(temp); return(temp);
@ -14,7 +14,7 @@ psb_d_t* psb_c_dvgather(psb_c_dvector *xh, psb_c_descriptor *cdh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_d_t *)malloc(vsize*sizeof(psb_d_t)))!=NULL) if ((temp=(psb_c_d_t *)malloc(vsize*sizeof(psb_c_d_t)))!=NULL)
psb_c_dvgather_f(temp,xh,cdh); psb_c_dvgather_f(temp,xh,cdh);
return(temp); return(temp);

20
cbind/base/psb_c_dcomm.h
Unescape Escape View File

@ -6,20 +6,20 @@
extern "C" { extern "C" {
#endif #endif
psb_i_t psb_c_dhalo(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dhalo(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dhalo_opt(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_dhalo_opt(psb_c_dvector *xh, psb_c_descriptor *cdh,
char *trans, psb_i_t mode); char *trans, psb_c_i_t mode);
psb_i_t psb_c_dovrl(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dovrl(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dovrl_opt(psb_c_dvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_dovrl_opt(psb_c_dvector *xh, psb_c_descriptor *cdh,
psb_i_t update, psb_i_t mode); psb_c_i_t update, psb_c_i_t mode);
psb_i_t psb_c_dvscatter(psb_l_t ng, psb_c_t *gx, psb_c_dvector *xh, psb_c_i_t psb_c_dvscatter(psb_c_l_t ng, psb_c_d_t *gx, psb_c_dvector *xh,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);
psb_d_t* psb_c_dvgather(psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_d_t* psb_c_dvgather(psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_c_dspmat* psb_c_dspgather(psb_c_dspmat *ah, psb_c_descriptor *cdh); psb_c_dspmat* psb_c_dspgather(psb_c_dspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_dvgather_f(psb_d_t* gv, psb_c_dvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_dvgather_f(psb_c_d_t* gv, psb_c_dvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_dspgather_f(psb_c_dspmat* ga, psb_c_dspmat *ah, psb_c_i_t psb_c_dspgather_f(psb_c_dspmat* ga, psb_c_dspmat *ah,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);

8
cbind/base/psb_c_sbase.c
Unescape Escape View File

@ -10,10 +10,10 @@ psb_c_svector* psb_c_new_svector()
return(temp); return(temp);
} }
psb_s_t* psb_c_svect_get_cpy(psb_c_svector *xh) psb_c_s_t* psb_c_svect_get_cpy(psb_c_svector *xh)
{ {
psb_s_t *temp=NULL; psb_c_s_t *temp=NULL;
psb_i_t vsize=0; psb_c_i_t vsize=0;
if ((vsize=psb_c_svect_get_nrows(xh))<0) if ((vsize=psb_c_svect_get_nrows(xh))<0)
return(temp); return(temp);
@ -21,7 +21,7 @@ psb_s_t* psb_c_svect_get_cpy(psb_c_svector *xh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_s_t *)malloc(vsize*sizeof(psb_s_t)))!=NULL) if ((temp=(psb_c_s_t *)malloc(vsize*sizeof(psb_c_s_t)))!=NULL)
psb_c_svect_f_get_cpy(temp,xh); psb_c_svect_f_get_cpy(temp,xh);
return(temp); return(temp);

160
cbind/base/psb_c_sbase.h
Unescape Escape View File

@ -17,103 +17,103 @@ typedef struct PSB_C_SSPMAT {
/* dense vectors */ /* dense vectors */
psb_c_svector* psb_c_new_svector(); psb_c_svector* psb_c_new_svector();
psb_i_t psb_c_svect_get_nrows(psb_c_svector *xh); psb_c_i_t psb_c_svect_get_nrows(psb_c_svector *xh);
psb_s_t *psb_c_svect_get_cpy(psb_c_svector *xh); psb_c_s_t *psb_c_svect_get_cpy(psb_c_svector *xh);
psb_i_t psb_c_svect_f_get_cpy(psb_s_t *v, psb_c_svector *xh); psb_c_i_t psb_c_svect_f_get_cpy(psb_c_s_t *v, psb_c_svector *xh);
psb_i_t psb_c_svect_zero(psb_c_svector *xh); psb_c_i_t psb_c_svect_zero(psb_c_svector *xh);
psb_s_t *psb_c_svect_f_get_pnt(psb_c_svector *xh); psb_c_s_t *psb_c_svect_f_get_pnt(psb_c_svector *xh);
psb_i_t psb_c_svect_clone(psb_c_svector *xh, psb_c_svector *yh); psb_c_i_t psb_c_svect_clone(psb_c_svector *xh, psb_c_svector *yh);
psb_i_t psb_c_sgeall(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeall(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeall_remote(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeall_remote(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeall_remote_options(psb_c_svector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_sgeall_remote_options(psb_c_svector *xh, psb_c_descriptor *cdh,
psb_i_t bldmode, psb_i_t dupl); psb_c_i_t bldmode, psb_c_i_t dupl);
psb_i_t psb_c_sgeins(psb_i_t nz, const psb_l_t *irw, const psb_s_t *val, psb_c_i_t psb_c_sgeins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_s_t *val,
psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeins_add(psb_i_t nz, const psb_l_t *irw, const psb_s_t *val, psb_c_i_t psb_c_sgeins_add(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_s_t *val,
psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeasb(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeasb(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeasb_options(psb_c_svector *xh, psb_c_descriptor *cdh, psb_i_t dupl); psb_c_i_t psb_c_sgeasb_options(psb_c_svector *xh, psb_c_descriptor *cdh, psb_c_i_t dupl);
psb_i_t psb_c_sgeasb_options_format(psb_c_svector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_sgeasb_options_format(psb_c_svector *xh, psb_c_descriptor *cdh,
psb_i_t dupl, const char *fmt); psb_c_i_t dupl, const char *fmt);
psb_i_t psb_c_sgefree(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgefree(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgereinit(psb_c_svector *xh, psb_c_descriptor *cdh, bool clear); psb_c_i_t psb_c_sgereinit(psb_c_svector *xh, psb_c_descriptor *cdh, bool clear);
psb_s_t psb_c_sgetelem(psb_c_svector *xh,psb_l_t index,psb_c_descriptor *cd); psb_c_s_t psb_c_sgetelem(psb_c_svector *xh,psb_c_l_t index,psb_c_descriptor *cd);
psb_s_t psb_c_smatgetelem(psb_c_sspmat *ah,psb_l_t rowindex,psb_l_t colindex,psb_c_descriptor *cdh); psb_c_s_t psb_c_smatgetelem(psb_c_sspmat *ah,psb_c_l_t rowindex,psb_c_l_t colindex,psb_c_descriptor *cdh);
psb_i_t psb_c_ssetelem(psb_l_t index, psb_s_t val, psb_c_i_t psb_c_ssetelem(psb_c_l_t index, psb_c_s_t val,
psb_c_svector *xh, psb_c_descriptor *cd); psb_c_svector *xh, psb_c_descriptor *cd);
/* sparse matrices*/ /* sparse matrices*/
psb_c_sspmat* psb_c_new_sspmat(); psb_c_sspmat* psb_c_new_sspmat();
psb_i_t psb_c_sspall(psb_c_sspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspall(psb_c_sspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspall_remote(psb_c_sspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspall_remote(psb_c_sspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspasb(psb_c_sspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspasb(psb_c_sspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspfree(psb_c_sspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspfree(psb_c_sspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspins(psb_i_t nz, const psb_l_t *irw, const psb_l_t *icl, psb_c_i_t psb_c_sspins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_l_t *icl,
const psb_s_t *val, psb_c_sspmat *mh, psb_c_descriptor *cdh); const psb_c_s_t *val, psb_c_sspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_smat_get_nrows(psb_c_sspmat *mh); psb_c_i_t psb_c_smat_get_nrows(psb_c_sspmat *mh);
psb_i_t psb_c_smat_get_ncols(psb_c_sspmat *mh); psb_c_i_t psb_c_smat_get_ncols(psb_c_sspmat *mh);
psb_l_t psb_c_snnz(psb_c_sspmat *mh,psb_c_descriptor *cdh); psb_c_l_t psb_c_snnz(psb_c_sspmat *mh,psb_c_descriptor *cdh);
bool psb_c_sis_matupd(psb_c_sspmat *mh,psb_c_descriptor *cdh); bool psb_c_sis_matupd(psb_c_sspmat *mh,psb_c_descriptor *cdh);
bool psb_c_sis_matasb(psb_c_sspmat *mh,psb_c_descriptor *cdh); bool psb_c_sis_matasb(psb_c_sspmat *mh,psb_c_descriptor *cdh);
bool psb_c_sis_matbld(psb_c_sspmat *mh,psb_c_descriptor *cdh); bool psb_c_sis_matbld(psb_c_sspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_sset_matupd(psb_c_sspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sset_matupd(psb_c_sspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_sset_matasb(psb_c_sspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sset_matasb(psb_c_sspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_sset_matbld(psb_c_sspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sset_matbld(psb_c_sspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_scopy_mat(psb_c_sspmat *ah,psb_c_sspmat *bh,psb_c_descriptor *cdh); psb_c_i_t psb_c_scopy_mat(psb_c_sspmat *ah,psb_c_sspmat *bh,psb_c_descriptor *cdh);
/* psb_i_t psb_c_sspasb_opt(psb_c_sspmat *mh, psb_c_descriptor *cdh, */ /* psb_c_i_t psb_c_sspasb_opt(psb_c_sspmat *mh, psb_c_descriptor *cdh, */
/* const char *afmt, psb_i_t upd, psb_i_t dupl); */ /* const char *afmt, psb_c_i_t upd, psb_c_i_t dupl); */
psb_i_t psb_c_ssprn(psb_c_sspmat *mh, psb_c_descriptor *cdh, _Bool clear); psb_c_i_t psb_c_ssprn(psb_c_sspmat *mh, psb_c_descriptor *cdh, _Bool clear);
psb_i_t psb_c_smat_name_print(psb_c_sspmat *mh, char *name); psb_c_i_t psb_c_smat_name_print(psb_c_sspmat *mh, char *name);
psb_i_t psb_c_svect_set_scal(psb_c_svector *xh, psb_s_t val); psb_c_i_t psb_c_svect_set_scal(psb_c_svector *xh, psb_c_s_t val);
psb_i_t psb_c_svect_set_scal_bound(psb_c_svector *xh, psb_s_t val, psb_c_i_t psb_c_svect_set_scal_bound(psb_c_svector *xh, psb_c_s_t val,
psb_i_t ifirst, psb_i_t ilast); psb_c_i_t ifirst, psb_c_i_t ilast);
psb_i_t psb_c_svect_set_vect(psb_c_svector *xh, psb_s_t *val, psb_i_t n); psb_c_i_t psb_c_svect_set_vect(psb_c_svector *xh, psb_c_s_t *val, psb_c_i_t n);
psb_s_t psb_c_svect_get_entry(psb_c_svector *xh, psb_i_t index); psb_c_s_t psb_c_svect_get_entry(psb_c_svector *xh, psb_c_i_t index);
psb_i_t psb_c_svect_set_entry(psb_c_svector *xh, psb_i_t index, psb_s_t val); psb_c_i_t psb_c_svect_set_entry(psb_c_svector *xh, psb_c_i_t index, psb_c_s_t val);
/* psblas computational routines */ /* psblas computational routines */
psb_s_t psb_c_sgedot(psb_c_svector *xh, psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_s_t psb_c_sgedot(psb_c_svector *xh, psb_c_svector *yh, psb_c_descriptor *cdh);
psb_s_t psb_c_sgenrm2(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_sgenrm2(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_sgeamax(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_sgeamax(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_sgeasum(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_s_t psb_c_sgeasum(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_s_t psb_c_sgenrmi(psb_c_svector *ah, psb_c_descriptor *cdh); psb_c_s_t psb_c_sgenrmi(psb_c_svector *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeaxpby(psb_s_t alpha, psb_c_svector *xh, psb_c_i_t psb_c_sgeaxpby(psb_c_s_t alpha, psb_c_svector *xh,
psb_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgeaxpbyz(psb_s_t alpha, psb_c_svector *xh, psb_c_i_t psb_c_sgeaxpbyz(psb_c_s_t alpha, psb_c_svector *xh,
psb_s_t beta, psb_c_svector *yh, psb_c_svector *zh, psb_c_descriptor *cdh); psb_c_s_t beta, psb_c_svector *yh, psb_c_svector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspmm(psb_s_t alpha, psb_c_sspmat *ah, psb_c_svector *xh, psb_c_i_t psb_c_sspmm(psb_c_s_t alpha, psb_c_sspmat *ah, psb_c_svector *xh,
psb_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspmm_opt(psb_s_t alpha, psb_c_sspmat *ah, psb_c_svector *xh, psb_c_i_t psb_c_sspmm_opt(psb_c_s_t alpha, psb_c_sspmat *ah, psb_c_svector *xh,
psb_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh, psb_c_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh,
char *trans, bool doswap); char *trans, bool doswap);
psb_i_t psb_c_sspsm(psb_s_t alpha, psb_c_sspmat *th, psb_c_svector *xh, psb_c_i_t psb_c_sspsm(psb_c_s_t alpha, psb_c_sspmat *th, psb_c_svector *xh,
psb_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_s_t beta, psb_c_svector *yh, psb_c_descriptor *cdh);
/* Additional computational routines */ /* Additional computational routines */
psb_i_t psb_c_sgemlt(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgemlt(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_sgemlt2(psb_s_t alpha, psb_c_svector *xh, psb_c_svector *yh, psb_s_t beta, psb_c_svector *zh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgemlt2(psb_c_s_t alpha, psb_c_svector *xh, psb_c_svector *yh, psb_c_s_t beta, psb_c_svector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgediv(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgediv(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_sgediv_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_sgediv_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_sgediv2(psb_c_svector *xh,psb_c_svector *yh,psb_c_svector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgediv2(psb_c_svector *xh,psb_c_svector *yh,psb_c_svector *zh,psb_c_descriptor *cdh);
psb_i_t psb_c_sgediv2_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_svector *zh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_sgediv2_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_svector *zh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_sgeinv(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeinv(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_sgeinv_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_sgeinv_check(psb_c_svector *xh,psb_c_svector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_sgeabs(psb_c_svector *xh,psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeabs(psb_c_svector *xh,psb_c_svector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_sgecmp(psb_c_svector *xh,psb_s_t ch,psb_c_svector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgecmp(psb_c_svector *xh,psb_c_s_t ch,psb_c_svector *zh,psb_c_descriptor *cdh);
bool psb_c_sgecmpmat(psb_c_sspmat *ah,psb_c_sspmat *bh,psb_s_t tol,psb_c_descriptor *cdh); bool psb_c_sgecmpmat(psb_c_sspmat *ah,psb_c_sspmat *bh,psb_c_s_t tol,psb_c_descriptor *cdh);
bool psb_c_sgecmpmat_val(psb_c_sspmat *ah,psb_s_t val,psb_s_t tol,psb_c_descriptor *cdh); bool psb_c_sgecmpmat_val(psb_c_sspmat *ah,psb_c_s_t val,psb_c_s_t tol,psb_c_descriptor *cdh);
psb_i_t psb_c_sgeaddconst(psb_c_svector *xh,psb_s_t bh,psb_c_svector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sgeaddconst(psb_c_svector *xh,psb_c_s_t bh,psb_c_svector *zh,psb_c_descriptor *cdh);
psb_s_t psb_c_sgenrm2_weight(psb_c_svector *xh,psb_c_svector *wh,psb_c_descriptor *cdh); psb_c_s_t psb_c_sgenrm2_weight(psb_c_svector *xh,psb_c_svector *wh,psb_c_descriptor *cdh);
psb_s_t psb_c_sgenrm2_weightmask(psb_c_svector *xh,psb_c_svector *wh,psb_c_svector *idvh,psb_c_descriptor *cdh); psb_c_s_t psb_c_sgenrm2_weightmask(psb_c_svector *xh,psb_c_svector *wh,psb_c_svector *idvh,psb_c_descriptor *cdh);
psb_i_t psb_c_smask(psb_c_svector *ch,psb_c_svector *xh,psb_c_svector *mh, bool *t, psb_c_descriptor *cdh); psb_c_i_t psb_c_smask(psb_c_svector *ch,psb_c_svector *xh,psb_c_svector *mh, bool *t, psb_c_descriptor *cdh);
psb_s_t psb_c_sgemin(psb_c_svector *xh,psb_c_descriptor *cdh); psb_c_s_t psb_c_sgemin(psb_c_svector *xh,psb_c_descriptor *cdh);
psb_s_t psb_c_sminquotient(psb_c_svector *xh,psb_c_svector *yh, psb_c_descriptor *cdh); psb_c_s_t psb_c_sminquotient(psb_c_svector *xh,psb_c_svector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspscal(psb_s_t alpha, psb_c_sspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspscal(psb_c_s_t alpha, psb_c_sspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_sspscalpid(psb_s_t alpha, psb_c_sspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspscalpid(psb_c_s_t alpha, psb_c_sspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_sspaxpby(psb_s_t alpha, psb_c_sspmat *ah, psb_s_t beta, psb_c_sspmat *bh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sspaxpby(psb_c_s_t alpha, psb_c_sspmat *ah, psb_c_s_t beta, psb_c_sspmat *bh, psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
cbind/base/psb_c_scomm.c
Unescape Escape View File

@ -3,10 +3,10 @@
#include "psb_c_sbase.h" #include "psb_c_sbase.h"
psb_s_t* psb_c_svgather(psb_c_svector *xh, psb_c_descriptor *cdh) psb_c_s_t* psb_c_svgather(psb_c_svector *xh, psb_c_descriptor *cdh)
{ {
psb_s_t *temp=NULL; psb_c_s_t *temp=NULL;
psb_l_t vsize=0; psb_c_l_t vsize=0;
if ((vsize=psb_c_cd_get_global_rows(cdh))<0) if ((vsize=psb_c_cd_get_global_rows(cdh))<0)
return(temp); return(temp);
@ -14,7 +14,7 @@ psb_s_t* psb_c_svgather(psb_c_svector *xh, psb_c_descriptor *cdh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_s_t *)malloc(vsize*sizeof(psb_s_t)))!=NULL) if ((temp=(psb_c_s_t *)malloc(vsize*sizeof(psb_c_s_t)))!=NULL)
psb_c_svgather_f(temp,xh,cdh); psb_c_svgather_f(temp,xh,cdh);
return(temp); return(temp);

20
cbind/base/psb_c_scomm.h
Unescape Escape View File

@ -6,20 +6,20 @@
extern "C" { extern "C" {
#endif #endif
psb_i_t psb_c_shalo(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_shalo(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_shalo_opt(psb_c_svector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_shalo_opt(psb_c_svector *xh, psb_c_descriptor *cdh,
char *trans, psb_i_t mode); char *trans, psb_c_i_t mode);
psb_i_t psb_c_sovrl(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_sovrl(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sovrl_opt(psb_c_svector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_sovrl_opt(psb_c_svector *xh, psb_c_descriptor *cdh,
psb_i_t update, psb_i_t mode); psb_c_i_t update, psb_c_i_t mode);
psb_i_t psb_c_svscatter(psb_l_t ng, psb_c_t *gx, psb_c_svector *xh, psb_c_i_t psb_c_svscatter(psb_c_l_t ng, psb_c_s_t *gx, psb_c_svector *xh,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);
psb_s_t* psb_c_svgather(psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_s_t* psb_c_svgather(psb_c_svector *xh, psb_c_descriptor *cdh);
psb_c_sspmat* psb_c_sspgather(psb_c_sspmat *ah, psb_c_descriptor *cdh); psb_c_sspmat* psb_c_sspgather(psb_c_sspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_svgather_f(psb_s_t* gv, psb_c_svector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_svgather_f(psb_c_s_t* gv, psb_c_svector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_sspgather_f(psb_c_sspmat* ga, psb_c_sspmat *ah, psb_c_i_t psb_c_sspgather_f(psb_c_sspmat* ga, psb_c_sspmat *ah,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);

8
cbind/base/psb_c_zbase.c
Unescape Escape View File

@ -10,10 +10,10 @@ psb_c_zvector* psb_c_new_zvector()
return(temp); return(temp);
} }
psb_z_t* psb_c_zvect_get_cpy(psb_c_zvector *xh) psb_c_z_t* psb_c_zvect_get_cpy(psb_c_zvector *xh)
{ {
psb_z_t *temp=NULL; psb_c_z_t *temp=NULL;
psb_i_t vsize=0; psb_c_i_t vsize=0;
if ((vsize=psb_c_zvect_get_nrows(xh))<0) if ((vsize=psb_c_zvect_get_nrows(xh))<0)
return(temp); return(temp);
@ -21,7 +21,7 @@ psb_z_t* psb_c_zvect_get_cpy(psb_c_zvector *xh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_z_t *)malloc(vsize*sizeof(psb_z_t)))!=NULL) if ((temp=(psb_c_z_t *)malloc(vsize*sizeof(psb_c_z_t)))!=NULL)
psb_c_zvect_f_get_cpy(temp,xh); psb_c_zvect_f_get_cpy(temp,xh);
return(temp); return(temp);

160
cbind/base/psb_c_zbase.h
Unescape Escape View File

@ -17,103 +17,103 @@ typedef struct PSB_C_ZSPMAT {
/* dense vectors */ /* dense vectors */
psb_c_zvector* psb_c_new_zvector(); psb_c_zvector* psb_c_new_zvector();
psb_i_t psb_c_zvect_get_nrows(psb_c_zvector *xh); psb_c_i_t psb_c_zvect_get_nrows(psb_c_zvector *xh);
psb_z_t *psb_c_zvect_get_cpy(psb_c_zvector *xh); psb_c_z_t *psb_c_zvect_get_cpy(psb_c_zvector *xh);
psb_i_t psb_c_zvect_f_get_cpy(psb_z_t *v, psb_c_zvector *xh); psb_c_i_t psb_c_zvect_f_get_cpy(psb_c_z_t *v, psb_c_zvector *xh);
psb_i_t psb_c_zvect_zero(psb_c_zvector *xh); psb_c_i_t psb_c_zvect_zero(psb_c_zvector *xh);
psb_z_t *psb_c_zvect_f_get_pnt(psb_c_zvector *xh); psb_c_z_t *psb_c_zvect_f_get_pnt(psb_c_zvector *xh);
psb_i_t psb_c_zvect_clone(psb_c_zvector *xh, psb_c_zvector *yh); psb_c_i_t psb_c_zvect_clone(psb_c_zvector *xh, psb_c_zvector *yh);
psb_i_t psb_c_zgeall(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeall(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeall_remote(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeall_remote(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeall_remote_options(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_zgeall_remote_options(psb_c_zvector *xh, psb_c_descriptor *cdh,
psb_i_t bldmode, psb_i_t dupl); psb_c_i_t bldmode, psb_c_i_t dupl);
psb_i_t psb_c_zgeins(psb_i_t nz, const psb_l_t *irw, const psb_z_t *val, psb_c_i_t psb_c_zgeins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_z_t *val,
psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeins_add(psb_i_t nz, const psb_l_t *irw, const psb_z_t *val, psb_c_i_t psb_c_zgeins_add(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_z_t *val,
psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeasb(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeasb(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeasb_options(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_i_t dupl); psb_c_i_t psb_c_zgeasb_options(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_c_i_t dupl);
psb_i_t psb_c_zgeasb_options_format(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_zgeasb_options_format(psb_c_zvector *xh, psb_c_descriptor *cdh,
psb_i_t dupl, const char *fmt); psb_c_i_t dupl, const char *fmt);
psb_i_t psb_c_zgefree(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgefree(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgereinit(psb_c_zvector *xh, psb_c_descriptor *cdh, bool clear); psb_c_i_t psb_c_zgereinit(psb_c_zvector *xh, psb_c_descriptor *cdh, bool clear);
psb_z_t psb_c_zgetelem(psb_c_zvector *xh,psb_l_t index,psb_c_descriptor *cd); psb_c_z_t psb_c_zgetelem(psb_c_zvector *xh,psb_c_l_t index,psb_c_descriptor *cd);
psb_z_t psb_c_zmatgetelem(psb_c_zspmat *ah,psb_l_t rowindex,psb_l_t colindex,psb_c_descriptor *cdh); psb_c_z_t psb_c_zmatgetelem(psb_c_zspmat *ah,psb_c_l_t rowindex,psb_c_l_t colindex,psb_c_descriptor *cdh);
psb_i_t psb_c_zsetelem(psb_l_t index, psb_z_t val, psb_c_i_t psb_c_zsetelem(psb_c_l_t index, psb_c_z_t val,
psb_c_zvector *xh, psb_c_descriptor *cd); psb_c_zvector *xh, psb_c_descriptor *cd);
/* sparse matrices*/ /* sparse matrices*/
psb_c_zspmat* psb_c_new_zspmat(); psb_c_zspmat* psb_c_new_zspmat();
psb_i_t psb_c_zspall(psb_c_zspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspall(psb_c_zspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspall_remote(psb_c_zspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspall_remote(psb_c_zspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspasb(psb_c_zspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspasb(psb_c_zspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspfree(psb_c_zspmat *mh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspfree(psb_c_zspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspins(psb_i_t nz, const psb_l_t *irw, const psb_l_t *icl, psb_c_i_t psb_c_zspins(psb_c_i_t nz, const psb_c_l_t *irw, const psb_c_l_t *icl,
const psb_z_t *val, psb_c_zspmat *mh, psb_c_descriptor *cdh); const psb_c_z_t *val, psb_c_zspmat *mh, psb_c_descriptor *cdh);
psb_i_t psb_c_zmat_get_nrows(psb_c_zspmat *mh); psb_c_i_t psb_c_zmat_get_nrows(psb_c_zspmat *mh);
psb_i_t psb_c_zmat_get_ncols(psb_c_zspmat *mh); psb_c_i_t psb_c_zmat_get_ncols(psb_c_zspmat *mh);
psb_l_t psb_c_znnz(psb_c_zspmat *mh,psb_c_descriptor *cdh); psb_c_l_t psb_c_znnz(psb_c_zspmat *mh,psb_c_descriptor *cdh);
bool psb_c_zis_matupd(psb_c_zspmat *mh,psb_c_descriptor *cdh); bool psb_c_zis_matupd(psb_c_zspmat *mh,psb_c_descriptor *cdh);
bool psb_c_zis_matasb(psb_c_zspmat *mh,psb_c_descriptor *cdh); bool psb_c_zis_matasb(psb_c_zspmat *mh,psb_c_descriptor *cdh);
bool psb_c_zis_matbld(psb_c_zspmat *mh,psb_c_descriptor *cdh); bool psb_c_zis_matbld(psb_c_zspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_zset_matupd(psb_c_zspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zset_matupd(psb_c_zspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_zset_matasb(psb_c_zspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zset_matasb(psb_c_zspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_zset_matbld(psb_c_zspmat *mh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zset_matbld(psb_c_zspmat *mh,psb_c_descriptor *cdh);
psb_i_t psb_c_zcopy_mat(psb_c_zspmat *ah,psb_c_zspmat *bh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zcopy_mat(psb_c_zspmat *ah,psb_c_zspmat *bh,psb_c_descriptor *cdh);
/* psb_i_t psb_c_zspasb_opt(psb_c_zspmat *mh, psb_c_descriptor *cdh, */ /* psb_c_i_t psb_c_zspasb_opt(psb_c_zspmat *mh, psb_c_descriptor *cdh, */
/* const char *afmt, psb_i_t upd, psb_i_t dupl); */ /* const char *afmt, psb_c_i_t upd, psb_c_i_t dupl); */
psb_i_t psb_c_zsprn(psb_c_zspmat *mh, psb_c_descriptor *cdh, _Bool clear); psb_c_i_t psb_c_zsprn(psb_c_zspmat *mh, psb_c_descriptor *cdh, _Bool clear);
psb_i_t psb_c_zmat_name_print(psb_c_zspmat *mh, char *name); psb_c_i_t psb_c_zmat_name_print(psb_c_zspmat *mh, char *name);
psb_i_t psb_c_zvect_set_scal(psb_c_zvector *xh, psb_z_t val); psb_c_i_t psb_c_zvect_set_scal(psb_c_zvector *xh, psb_c_z_t val);
psb_i_t psb_c_zvect_set_scal_bound(psb_c_zvector *xh, psb_z_t val, psb_c_i_t psb_c_zvect_set_scal_bound(psb_c_zvector *xh, psb_c_z_t val,
psb_i_t ifirst, psb_i_t ilast); psb_c_i_t ifirst, psb_c_i_t ilast);
psb_i_t psb_c_zvect_set_vect(psb_c_zvector *xh, psb_z_t *val, psb_i_t n); psb_c_i_t psb_c_zvect_set_vect(psb_c_zvector *xh, psb_c_z_t *val, psb_c_i_t n);
psb_z_t psb_c_zvect_get_entry(psb_c_zvector *xh, psb_i_t index); psb_c_z_t psb_c_zvect_get_entry(psb_c_zvector *xh, psb_c_i_t index);
psb_i_t psb_c_zvect_set_entry(psb_c_zvector *xh, psb_i_t index, psb_z_t val); psb_c_i_t psb_c_zvect_set_entry(psb_c_zvector *xh, psb_c_i_t index, psb_c_z_t val);
/* psblas computational routines */ /* psblas computational routines */
psb_z_t psb_c_zgedot(psb_c_zvector *xh, psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_z_t psb_c_zgedot(psb_c_zvector *xh, psb_c_zvector *yh, psb_c_descriptor *cdh);
psb_d_t psb_c_zgenrm2(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_zgenrm2(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_zgeamax(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_zgeamax(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_zgeasum(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_d_t psb_c_zgeasum(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_d_t psb_c_zgenrmi(psb_c_zvector *ah, psb_c_descriptor *cdh); psb_c_d_t psb_c_zgenrmi(psb_c_zvector *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeaxpby(psb_z_t alpha, psb_c_zvector *xh, psb_c_i_t psb_c_zgeaxpby(psb_c_z_t alpha, psb_c_zvector *xh,
psb_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgeaxpbyz(psb_z_t alpha, psb_c_zvector *xh, psb_c_i_t psb_c_zgeaxpbyz(psb_c_z_t alpha, psb_c_zvector *xh,
psb_z_t beta, psb_c_zvector *yh, psb_c_zvector *zh, psb_c_descriptor *cdh); psb_c_z_t beta, psb_c_zvector *yh, psb_c_zvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspmm(psb_z_t alpha, psb_c_zspmat *ah, psb_c_zvector *xh, psb_c_i_t psb_c_zspmm(psb_c_z_t alpha, psb_c_zspmat *ah, psb_c_zvector *xh,
psb_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspmm_opt(psb_z_t alpha, psb_c_zspmat *ah, psb_c_zvector *xh, psb_c_i_t psb_c_zspmm_opt(psb_c_z_t alpha, psb_c_zspmat *ah, psb_c_zvector *xh,
psb_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh, psb_c_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh,
char *trans, bool doswap); char *trans, bool doswap);
psb_i_t psb_c_zspsm(psb_z_t alpha, psb_c_zspmat *th, psb_c_zvector *xh, psb_c_i_t psb_c_zspsm(psb_c_z_t alpha, psb_c_zspmat *th, psb_c_zvector *xh,
psb_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_z_t beta, psb_c_zvector *yh, psb_c_descriptor *cdh);
/* Additional computational routines */ /* Additional computational routines */
psb_i_t psb_c_zgemlt(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgemlt(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_zgemlt2(psb_z_t alpha, psb_c_zvector *xh, psb_c_zvector *yh, psb_z_t beta, psb_c_zvector *zh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgemlt2(psb_c_z_t alpha, psb_c_zvector *xh, psb_c_zvector *yh, psb_c_z_t beta, psb_c_zvector *zh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgediv(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgediv(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_zgediv_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_zgediv_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_zgediv2(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_zvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgediv2(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_zvector *zh,psb_c_descriptor *cdh);
psb_i_t psb_c_zgediv2_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_zvector *zh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_zgediv2_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_zvector *zh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_zgeinv(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeinv(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh);
psb_i_t psb_c_zgeinv_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh, bool flag); psb_c_i_t psb_c_zgeinv_check(psb_c_zvector *xh,psb_c_zvector *yh,psb_c_descriptor *cdh, bool flag);
psb_i_t psb_c_zgeabs(psb_c_zvector *xh,psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeabs(psb_c_zvector *xh,psb_c_zvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_zgecmp(psb_c_zvector *xh,psb_d_t ch,psb_c_zvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgecmp(psb_c_zvector *xh,psb_c_d_t ch,psb_c_zvector *zh,psb_c_descriptor *cdh);
bool psb_c_zgecmpmat(psb_c_zspmat *ah,psb_c_zspmat *bh,psb_d_t tol,psb_c_descriptor *cdh); bool psb_c_zgecmpmat(psb_c_zspmat *ah,psb_c_zspmat *bh,psb_c_d_t tol,psb_c_descriptor *cdh);
bool psb_c_zgecmpmat_val(psb_c_zspmat *ah,psb_z_t val,psb_d_t tol,psb_c_descriptor *cdh); bool psb_c_zgecmpmat_val(psb_c_zspmat *ah,psb_c_z_t val,psb_c_d_t tol,psb_c_descriptor *cdh);
psb_i_t psb_c_zgeaddconst(psb_c_zvector *xh,psb_z_t bh,psb_c_zvector *zh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zgeaddconst(psb_c_zvector *xh,psb_c_z_t bh,psb_c_zvector *zh,psb_c_descriptor *cdh);
psb_d_t psb_c_zgenrm2_weight(psb_c_zvector *xh,psb_c_zvector *wh,psb_c_descriptor *cdh); psb_c_d_t psb_c_zgenrm2_weight(psb_c_zvector *xh,psb_c_zvector *wh,psb_c_descriptor *cdh);
psb_d_t psb_c_zgenrm2_weightmask(psb_c_zvector *xh,psb_c_zvector *wh,psb_c_zvector *idvh,psb_c_descriptor *cdh); psb_c_d_t psb_c_zgenrm2_weightmask(psb_c_zvector *xh,psb_c_zvector *wh,psb_c_zvector *idvh,psb_c_descriptor *cdh);
psb_i_t psb_c_zmask(psb_c_zvector *ch,psb_c_zvector *xh,psb_c_zvector *mh, bool *t, psb_c_descriptor *cdh); psb_c_i_t psb_c_zmask(psb_c_zvector *ch,psb_c_zvector *xh,psb_c_zvector *mh, bool *t, psb_c_descriptor *cdh);
psb_z_t psb_c_zgemin(psb_c_zvector *xh,psb_c_descriptor *cdh); psb_c_z_t psb_c_zgemin(psb_c_zvector *xh,psb_c_descriptor *cdh);
psb_z_t psb_c_zminquotient(psb_c_zvector *xh,psb_c_zvector *yh, psb_c_descriptor *cdh); psb_c_z_t psb_c_zminquotient(psb_c_zvector *xh,psb_c_zvector *yh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspscal(psb_z_t alpha, psb_c_zspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspscal(psb_c_z_t alpha, psb_c_zspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_zspscalpid(psb_z_t alpha, psb_c_zspmat *ah, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspscalpid(psb_c_z_t alpha, psb_c_zspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_zspaxpby(psb_z_t alpha, psb_c_zspmat *ah, psb_z_t beta, psb_c_zspmat *bh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zspaxpby(psb_c_z_t alpha, psb_c_zspmat *ah, psb_c_z_t beta, psb_c_zspmat *bh, psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
cbind/base/psb_c_zcomm.c
Unescape Escape View File

@ -3,10 +3,10 @@
#include "psb_c_zbase.h" #include "psb_c_zbase.h"
psb_z_t* psb_c_zvgather(psb_c_zvector *xh, psb_c_descriptor *cdh) psb_c_z_t* psb_c_zvgather(psb_c_zvector *xh, psb_c_descriptor *cdh)
{ {
psb_z_t *temp=NULL; psb_c_z_t *temp=NULL;
psb_l_t vsize=0; psb_c_l_t vsize=0;
if ((vsize=psb_c_cd_get_global_rows(cdh))<0) if ((vsize=psb_c_cd_get_global_rows(cdh))<0)
return(temp); return(temp);
@ -14,7 +14,7 @@ psb_z_t* psb_c_zvgather(psb_c_zvector *xh, psb_c_descriptor *cdh)
if (vsize==0) if (vsize==0)
vsize=1; vsize=1;
if ((temp=(psb_z_t *)malloc(vsize*sizeof(psb_z_t)))!=NULL) if ((temp=(psb_c_z_t *)malloc(vsize*sizeof(psb_c_z_t)))!=NULL)
psb_c_zvgather_f(temp,xh,cdh); psb_c_zvgather_f(temp,xh,cdh);
return(temp); return(temp);

20
cbind/base/psb_c_zcomm.h
Unescape Escape View File

@ -6,20 +6,20 @@
extern "C" { extern "C" {
#endif #endif
psb_i_t psb_c_zhalo(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zhalo(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zhalo_opt(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_zhalo_opt(psb_c_zvector *xh, psb_c_descriptor *cdh,
char *trans, psb_i_t mode); char *trans, psb_c_i_t mode);
psb_i_t psb_c_zovrl(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zovrl(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zovrl_opt(psb_c_zvector *xh, psb_c_descriptor *cdh, psb_c_i_t psb_c_zovrl_opt(psb_c_zvector *xh, psb_c_descriptor *cdh,
psb_i_t update, psb_i_t mode); psb_c_i_t update, psb_c_i_t mode);
psb_i_t psb_c_zvscatter(psb_l_t ng, psb_c_t *gx, psb_c_zvector *xh, psb_c_i_t psb_c_zvscatter(psb_c_l_t ng, psb_c_z_t *gx, psb_c_zvector *xh,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);
psb_z_t* psb_c_zvgather(psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_z_t* psb_c_zvgather(psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_c_zspmat* psb_c_zspgather(psb_c_zspmat *ah, psb_c_descriptor *cdh); psb_c_zspmat* psb_c_zspgather(psb_c_zspmat *ah, psb_c_descriptor *cdh);
psb_i_t psb_c_zvgather_f(psb_z_t* gv, psb_c_zvector *xh, psb_c_descriptor *cdh); psb_c_i_t psb_c_zvgather_f(psb_c_z_t* gv, psb_c_zvector *xh, psb_c_descriptor *cdh);
psb_i_t psb_c_zspgather_f(psb_c_zspmat* ga, psb_c_zspmat *ah, psb_c_i_t psb_c_zspgather_f(psb_c_zspmat* ga, psb_c_zspmat *ah,
psb_c_descriptor *cdh); psb_c_descriptor *cdh);

30
cbind/linsolve/psb_linsolve_cbind.h
Unescape Escape View File

@ -15,49 +15,49 @@ extern "C" {
/* Drawback: we end up defining defaults in two places */ /* Drawback: we end up defining defaults in two places */
/* Note: must be interoperable */ /* Note: must be interoperable */
typedef struct psb_c_solveroptions { typedef struct psb_c_solveroptions {
int iter; /* On exit how many iterations were performed */ psb_c_i_t iter; /* On exit how many iterations were performed */
int itmax; /* On entry maximum number of iterations */ psb_c_i_t itmax; /* On entry maximum number of iterations */
int itrace; /* On entry print an info message every itrace iterations */ psb_c_i_t itrace; /* On entry print an info message every itrace iterations */
int irst; /* Restart depth for RGMRES or BiCGSTAB(L) */ psb_c_i_t irst; /* Restart depth for RGMRES or BiCGSTAB(L) */
int istop; /* Stopping criterion: 1:backward error 2: ||r||_2/||b||_2 */ psb_c_i_t istop; /* Stopping criterion: 1:backward error 2: ||r||_2/||b||_2 */
double eps; /* Stopping tolerance */ double eps; /* Stopping tolerance */
double err; /* Convergence indicator on exit */ double err; /* Convergence indicator on exit */
} psb_c_SolverOptions; } psb_c_SolverOptions;
int psb_c_DefaultSolverOptions(psb_c_SolverOptions *opt); psb_c_i_t psb_c_DefaultSolverOptions(psb_c_SolverOptions *opt);
int psb_c_PrintSolverOptions(psb_c_SolverOptions *opt); psb_c_i_t psb_c_PrintSolverOptions(psb_c_SolverOptions *opt);
int psb_c_skrylov(const char *method, psb_c_sspmat *ah, psb_c_sprec *ph, psb_c_i_t psb_c_skrylov(const char *method, psb_c_sspmat *ah, psb_c_sprec *ph,
psb_c_svector *bh, psb_c_svector *xh, psb_c_svector *bh, psb_c_svector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_dkrylov(const char *method, psb_c_dspmat *ah, psb_c_dprec *ph, psb_c_i_t psb_c_dkrylov(const char *method, psb_c_dspmat *ah, psb_c_dprec *ph,
psb_c_dvector *bh, psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_ckrylov(const char *method, psb_c_cspmat *ah, psb_c_cprec *ph, psb_c_i_t psb_c_ckrylov(const char *method, psb_c_cspmat *ah, psb_c_cprec *ph,
psb_c_cvector *bh, psb_c_cvector *xh, psb_c_cvector *bh, psb_c_cvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_zkrylov(const char *method, psb_c_zspmat *ah, psb_c_zprec *ph, psb_c_i_t psb_c_zkrylov(const char *method, psb_c_zspmat *ah, psb_c_zprec *ph,
psb_c_zvector *bh, psb_c_zvector *xh, psb_c_zvector *bh, psb_c_zvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_srichardson(psb_c_sspmat *ah, psb_c_sprec *ph, psb_c_i_t psb_c_srichardson(psb_c_sspmat *ah, psb_c_sprec *ph,
psb_c_svector *bh, psb_c_svector *xh, psb_c_svector *bh, psb_c_svector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_drichardson(psb_c_dspmat *ah, psb_c_dprec *ph, psb_c_i_t psb_c_drichardson(psb_c_dspmat *ah, psb_c_dprec *ph,
psb_c_dvector *bh, psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_crichardson(psb_c_cspmat *ah, psb_c_cprec *ph, psb_c_i_t psb_c_crichardson(psb_c_cspmat *ah, psb_c_cprec *ph,
psb_c_cvector *bh, psb_c_cvector *xh, psb_c_cvector *bh, psb_c_cvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);
int psb_c_zrichardson(psb_c_zspmat *ah, psb_c_zprec *ph, psb_c_i_t psb_c_zrichardson(psb_c_zspmat *ah, psb_c_zprec *ph,
psb_c_zvector *bh, psb_c_zvector *xh, psb_c_zvector *bh, psb_c_zvector *xh,
psb_c_descriptor *cdh, psb_c_SolverOptions *opt); psb_c_descriptor *cdh, psb_c_SolverOptions *opt);

6
cbind/prec/psb_c_cprec.h
Unescape Escape View File

@ -14,9 +14,9 @@ extern "C" {
psb_c_cprec* psb_c_new_cprec(); psb_c_cprec* psb_c_new_cprec();
psb_i_t psb_c_cprecinit(psb_c_ctxt cctxt,psb_c_cprec *ph, const char *ptype); psb_c_i_t psb_c_cprecinit(psb_c_ctxt cctxt,psb_c_cprec *ph, const char *ptype);
psb_i_t psb_c_cprecbld(psb_c_cspmat *ah, psb_c_descriptor *cdh, psb_c_cprec *ph); psb_c_i_t psb_c_cprecbld(psb_c_cspmat *ah, psb_c_descriptor *cdh, psb_c_cprec *ph);
psb_i_t psb_c_cprecfree(psb_c_cprec *ph); psb_c_i_t psb_c_cprecfree(psb_c_cprec *ph);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
cbind/prec/psb_c_dprec.h
Unescape Escape View File

@ -14,9 +14,9 @@ extern "C" {
psb_c_dprec* psb_c_new_dprec(); psb_c_dprec* psb_c_new_dprec();
psb_i_t psb_c_dprecinit(psb_c_ctxt cctxt, psb_c_dprec *ph, const char *ptype); psb_c_i_t psb_c_dprecinit(psb_c_ctxt cctxt, psb_c_dprec *ph, const char *ptype);
psb_i_t psb_c_dprecbld(psb_c_dspmat *ah, psb_c_descriptor *cdh, psb_c_dprec *ph); psb_c_i_t psb_c_dprecbld(psb_c_dspmat *ah, psb_c_descriptor *cdh, psb_c_dprec *ph);
psb_i_t psb_c_dprecfree(psb_c_dprec *ph); psb_c_i_t psb_c_dprecfree(psb_c_dprec *ph);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
cbind/prec/psb_c_sprec.h
Unescape Escape View File

@ -14,9 +14,9 @@ extern "C" {
psb_c_sprec* psb_c_new_sprec(); psb_c_sprec* psb_c_new_sprec();
psb_i_t psb_c_sprecinit(psb_c_ctxt cctxt, psb_c_sprec *ph, const char *ptype); psb_c_i_t psb_c_sprecinit(psb_c_ctxt cctxt, psb_c_sprec *ph, const char *ptype);
psb_i_t psb_c_sprecbld(psb_c_sspmat *ah, psb_c_descriptor *cdh, psb_c_sprec *ph); psb_c_i_t psb_c_sprecbld(psb_c_sspmat *ah, psb_c_descriptor *cdh, psb_c_sprec *ph);
psb_i_t psb_c_sprecfree(psb_c_sprec *ph); psb_c_i_t psb_c_sprecfree(psb_c_sprec *ph);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
cbind/prec/psb_c_zprec.h
Unescape Escape View File

@ -14,9 +14,9 @@ extern "C" {
psb_c_zprec* psb_c_new_zprec(); psb_c_zprec* psb_c_new_zprec();
psb_i_t psb_c_zprecinit(psb_c_ctxt cctxt, psb_c_zprec *ph, const char *ptype); psb_c_i_t psb_c_zprecinit(psb_c_ctxt cctxt, psb_c_zprec *ph, const char *ptype);
psb_i_t psb_c_zprecbld(psb_c_zspmat *ah, psb_c_descriptor *cdh, psb_c_zprec *ph); psb_c_i_t psb_c_zprecbld(psb_c_zspmat *ah, psb_c_descriptor *cdh, psb_c_zprec *ph);
psb_i_t psb_c_zprecfree(psb_c_zprec *ph); psb_c_i_t psb_c_zprecfree(psb_c_zprec *ph);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

4
cbind/test/gpu/gputest.c
Unescape Escape View File

@ -38,7 +38,7 @@
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
psb_c_ctxt *cctxt; psb_c_ctxt *cctxt;
psb_i_t iam, np; psb_c_i_t iam, np;
// Initialize PSBLAS context // Initialize PSBLAS context
cctxt = psb_c_new_ctxt(); cctxt = psb_c_new_ctxt();
@ -61,4 +61,4 @@ int main(int argc, char **argv)
// Finalize PSBLAS context // Finalize PSBLAS context
psb_c_exit(*cctxt); psb_c_exit(*cctxt);
free(cctxt); free(cctxt);
} }

26
cbind/test/gpu/pdegen3dc.c
Unescape Escape View File

@ -125,17 +125,17 @@ double g(double x, double y, double z)
} }
} }
psb_i_t matgen(psb_c_ctxt cctxt, psb_i_t nl, psb_i_t idim, psb_l_t vl[], psb_c_i_t matgen(psb_c_ctxt cctxt, psb_c_i_t nl, psb_c_i_t idim, psb_c_l_t vl[],
psb_c_dspmat *ah, const char *afmt, psb_c_dspmat *ah, const char *afmt,
psb_c_descriptor *cdh, const char *cdfmt, psb_c_descriptor *cdh, const char *cdfmt,
psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *rh) psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *rh)
{ {
psb_i_t iam, np; psb_c_i_t iam, np;
psb_l_t ix, iy, iz, el, glob_row; psb_c_l_t ix, iy, iz, el, glob_row;
psb_i_t i, k, info, ret; psb_c_i_t i, k, info, ret;
double x, y, z, deltah, sqdeltah, deltah2; double x, y, z, deltah, sqdeltah, deltah2;
double val[10 * NBMAX], zt[NBMAX]; double val[10 * NBMAX], zt[NBMAX];
psb_l_t irow[10 * NBMAX], icol[10 * NBMAX]; psb_c_l_t irow[10 * NBMAX], icol[10 * NBMAX];
info = 0; info = 0;
psb_c_info(cctxt, &iam, &np); psb_c_info(cctxt, &iam, &np);
@ -272,15 +272,15 @@ psb_i_t matgen(psb_c_ctxt cctxt, psb_i_t nl, psb_i_t idim, psb_l_t vl[],
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
psb_c_ctxt *cctxt; psb_c_ctxt *cctxt;
psb_i_t iam, np; psb_c_i_t iam, np;
char methd[40], ptype[20], afmt[8], cdfmt[8], buffer[LINEBUFSIZE + 1]; char methd[40], ptype[20], afmt[8], cdfmt[8], buffer[LINEBUFSIZE + 1];
psb_i_t nparms; psb_c_i_t nparms;
psb_i_t idim, info, istop, itmax, itrace, irst, iter, ret; psb_c_i_t idim, info, istop, itmax, itrace, irst, iter, ret;
psb_c_dprec *ph; psb_c_dprec *ph;
psb_c_dspmat *ah; psb_c_dspmat *ah;
psb_c_dvector *bh, *xh, *rh; psb_c_dvector *bh, *xh, *rh;
psb_i_t nb, nlr, nl; psb_c_i_t nb, nlr, nl;
psb_l_t i, ng, *vl, k; psb_c_l_t i, ng, *vl, k;
double t1, t2, eps, err; double t1, t2, eps, err;
double *xv, *bv, *rv; double *xv, *bv, *rv;
double one = 1.0, zero = 0.0, res2; double one = 1.0, zero = 0.0, res2;
@ -354,17 +354,17 @@ int main(int argc, char *argv[])
psb_c_set_index_base(0); psb_c_set_index_base(0);
/* Simple minded BLOCK data distribution */ /* Simple minded BLOCK data distribution */
ng = ((psb_l_t)idim) * idim * idim; ng = ((psb_c_l_t)idim) * idim * idim;
nb = (ng + np - 1) / np; nb = (ng + np - 1) / np;
nl = nb; nl = nb;
if ((ng - iam * nb) < nl) if ((ng - iam * nb) < nl)
nl = ng - iam * nb; nl = ng - iam * nb;
if ((vl = malloc(nb * sizeof(psb_l_t))) == NULL) if ((vl = malloc(nb * sizeof(psb_c_l_t))) == NULL)
{ {
fprintf(stderr, "On %d: malloc failure\n", iam); fprintf(stderr, "On %d: malloc failure\n", iam);
psb_c_abort(*cctxt); psb_c_abort(*cctxt);
} }
i = ((psb_l_t)iam) * nb; i = ((psb_c_l_t)iam) * nb;
for (k = 0; k < nl; k++) for (k = 0; k < nl; k++)
vl[k] = i + k; vl[k] = i + k;

26
cbind/test/pdegen/pdegen3dc.c
Unescape Escape View File

@ -120,16 +120,16 @@ double g(double x, double y, double z)
} }
} }
psb_i_t matgen(psb_c_ctxt cctxt, psb_i_t nl, psb_i_t idim, psb_l_t vl[], psb_c_i_t matgen(psb_c_ctxt cctxt, psb_c_i_t nl, psb_c_i_t idim, psb_c_l_t vl[],
psb_c_dspmat *ah,psb_c_descriptor *cdh, psb_c_dspmat *ah,psb_c_descriptor *cdh,
psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *rh) psb_c_dvector *xh, psb_c_dvector *bh, psb_c_dvector *rh)
{ {
psb_i_t iam, np; psb_c_i_t iam, np;
psb_l_t ix, iy, iz, el,glob_row; psb_c_l_t ix, iy, iz, el,glob_row;
psb_i_t i, k, info,ret; psb_c_i_t i, k, info,ret;
double x, y, z, deltah, sqdeltah, deltah2; double x, y, z, deltah, sqdeltah, deltah2;
double val[10*NBMAX], zt[NBMAX]; double val[10*NBMAX], zt[NBMAX];
psb_l_t irow[10*NBMAX], icol[10*NBMAX]; psb_c_l_t irow[10*NBMAX], icol[10*NBMAX];
info = 0; info = 0;
psb_c_info(cctxt,&iam,&np); psb_c_info(cctxt,&iam,&np);
@ -224,15 +224,15 @@ psb_i_t matgen(psb_c_ctxt cctxt, psb_i_t nl, psb_i_t idim, psb_l_t vl[],
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
psb_c_ctxt *cctxt; psb_c_ctxt *cctxt;
psb_i_t iam, np; psb_c_i_t iam, np;
char methd[40], ptype[20], afmt[8], buffer[LINEBUFSIZE+1]; char methd[40], ptype[20], afmt[8], buffer[LINEBUFSIZE+1];
psb_i_t nparms; psb_c_i_t nparms;
psb_i_t idim,info,istop,itmax,itrace,irst,iter,ret; psb_c_i_t idim,info,istop,itmax,itrace,irst,iter,ret;
psb_c_dprec *ph; psb_c_dprec *ph;
psb_c_dspmat *ah; psb_c_dspmat *ah;
psb_c_dvector *bh, *xh, *rh; psb_c_dvector *bh, *xh, *rh;
psb_i_t nb,nlr, nl; psb_c_i_t nb,nlr, nl;
psb_l_t i,ng, *vl, k; psb_c_l_t i,ng, *vl, k;
double t1,t2,eps,err; double t1,t2,eps,err;
double *xv, *bv, *rv; double *xv, *bv, *rv;
double one=1.0, zero=0.0, res2; double one=1.0, zero=0.0, res2;
@ -283,15 +283,15 @@ int main(int argc, char *argv[])
psb_c_set_index_base(0); psb_c_set_index_base(0);
/* Simple minded BLOCK data distribution */ /* Simple minded BLOCK data distribution */
ng = ((psb_l_t) idim)*idim*idim; ng = ((psb_c_l_t) idim)*idim*idim;
nb = (ng+np-1)/np; nb = (ng+np-1)/np;
nl = nb; nl = nb;
if ( (ng -iam*nb) < nl) nl = ng -iam*nb; if ( (ng -iam*nb) < nl) nl = ng -iam*nb;
if ((vl=malloc(nb*sizeof(psb_l_t)))==NULL) { if ((vl=malloc(nb*sizeof(psb_c_l_t)))==NULL) {
fprintf(stderr,"On %d: malloc failure\n",iam); fprintf(stderr,"On %d: malloc failure\n",iam);
psb_c_abort(*cctxt); psb_c_abort(*cctxt);
} }
i = ((psb_l_t)iam) * nb; i = ((psb_c_l_t)iam) * nb;
for (k=0; k<nl; k++) for (k=0; k<nl; k++)
vl[k] = i+k; vl[k] = i+k;

6
cbind/util/psb_c_cutil.h
Unescape Escape View File

@ -7,9 +7,9 @@ extern "C" {
#endif #endif
/* I/O Routine */ /* I/O Routine */
psb_i_t psb_c_cmm_mat_write(psb_c_cspmat *ah, char *matrixtitle, char *filename); psb_c_i_t psb_c_cmm_mat_write(psb_c_cspmat *ah, char *matrixtitle, char *filename);
psb_i_t psb_c_cglobal_mat_write(psb_c_cspmat *ah,psb_c_descriptor *cdh); psb_c_i_t psb_c_cglobal_mat_write(psb_c_cspmat *ah,psb_c_descriptor *cdh);
psb_i_t psb_c_cglobal_vec_write(psb_c_cvector *vh,psb_c_descriptor *cdh); psb_c_i_t psb_c_cglobal_vec_write(psb_c_cvector *vh,psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

6
cbind/util/psb_c_dutil.h
Unescape Escape View File

@ -7,9 +7,9 @@ extern "C" {
#endif #endif
/* I/O Routine */ /* I/O Routine */
psb_i_t psb_c_dmm_mat_write(psb_c_dspmat *ah, char *matrixtitle, char *filename); psb_c_i_t psb_c_dmm_mat_write(psb_c_dspmat *ah, char *matrixtitle, char *filename);
psb_i_t psb_c_dglobal_mat_write(psb_c_dspmat *ah,psb_c_descriptor *cdh); psb_c_i_t psb_c_dglobal_mat_write(psb_c_dspmat *ah,psb_c_descriptor *cdh);
psb_i_t psb_c_dglobal_vec_write(psb_c_dvector *vh,psb_c_descriptor *cdh); psb_c_i_t psb_c_dglobal_vec_write(psb_c_dvector *vh,psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

6
cbind/util/psb_c_sutil.h
Unescape Escape View File

@ -7,9 +7,9 @@ extern "C" {
#endif #endif
/* I/O Routine */ /* I/O Routine */
psb_i_t psb_c_smm_mat_write(psb_c_sspmat *ah, char *matrixtitle, char *filename); psb_c_i_t psb_c_smm_mat_write(psb_c_sspmat *ah, char *matrixtitle, char *filename);
psb_i_t psb_c_sglobal_mat_write(psb_c_sspmat *ah,psb_c_descriptor *cdh); psb_c_i_t psb_c_sglobal_mat_write(psb_c_sspmat *ah,psb_c_descriptor *cdh);
psb_i_t psb_c_sglobal_vec_write(psb_c_svector *vh,psb_c_descriptor *cdh); psb_c_i_t psb_c_sglobal_vec_write(psb_c_svector *vh,psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

6
cbind/util/psb_c_zutil.h
Unescape Escape View File

@ -7,9 +7,9 @@ extern "C" {
#endif #endif
/* I/O Routine */ /* I/O Routine */
psb_i_t psb_c_zmm_mat_write(psb_c_zspmat *ah, char *matrixtitle, char *filename); psb_c_i_t psb_c_zmm_mat_write(psb_c_zspmat *ah, char *matrixtitle, char *filename);
psb_i_t psb_c_zglobal_mat_write(psb_c_zspmat *ah,psb_c_descriptor *cdh); psb_c_i_t psb_c_zglobal_mat_write(psb_c_zspmat *ah,psb_c_descriptor *cdh);
psb_i_t psb_c_zglobal_vec_write(psb_c_zvector *vh,psb_c_descriptor *cdh); psb_c_i_t psb_c_zglobal_vec_write(psb_c_zvector *vh,psb_c_descriptor *cdh);
#ifdef __cplusplus #ifdef __cplusplus
} }

10
cbind/util/psb_util_cbind.h
Unescape Escape View File

@ -6,10 +6,10 @@
#include "psb_c_cutil.h" #include "psb_c_cutil.h"
#include "psb_c_zutil.h" #include "psb_c_zutil.h"
psb_i_t psb_c_i_idx2ijk(psb_i_t ijk[],psb_i_t idx,psb_i_t sizes[],psb_i_t modes,psb_i_t base); psb_c_i_t psb_c_i_idx2ijk(psb_c_i_t ijk[],psb_c_i_t idx,psb_c_i_t sizes[],psb_c_i_t modes,psb_c_i_t base);
psb_i_t psb_c_l_idx2ijk(psb_i_t ijk[],psb_l_t idx,psb_i_t sizes[],psb_i_t modes,psb_i_t base); psb_c_i_t psb_c_l_idx2ijk(psb_c_i_t ijk[],psb_c_l_t idx,psb_c_i_t sizes[],psb_c_i_t modes,psb_c_i_t base);
psb_i_t psb_c_i_ijk2idx(psb_i_t ijk[],psb_i_t sizes[],psb_i_t modes,psb_i_t base); psb_c_i_t psb_c_i_ijk2idx(psb_c_i_t ijk[],psb_c_i_t sizes[],psb_c_i_t modes,psb_c_i_t base);
psb_l_t psb_c_l_ijk2idx(psb_i_t ijk[],psb_i_t sizes[],psb_i_t modes,psb_i_t base); psb_c_l_t psb_c_l_ijk2idx(psb_c_i_t ijk[],psb_c_i_t sizes[],psb_c_i_t modes,psb_c_i_t base);
psb_i_t psb_c_dist1didx(psb_i_t n, psb_i_t np, psb_i_t base, psb_i_t indexsize, psb_i_t v[]); psb_c_i_t psb_c_dist1didx(psb_c_i_t n, psb_c_i_t np, psb_c_i_t base, psb_c_i_t indexsize, psb_c_i_t v[]);
#endif #endif

Write Preview
Loading…
Cancel
Save