LIS_INT lis_esolver_get_iters(LIS_ESOLVER esolver, LIS_VECTOR v)
{
LIS_INT i,ii,ss,n,gn,is,ie;
LIS_DEBUG_FUNC_IN;
if ( esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_SI && esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_LI && esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_AI )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_ESOLVER is %d (Set Subspace, Lanczos, or Arnoldi)\n", esolver->options[LIS_EOPTIONS_ESOLVER]);
return LIS_ERR_ILL_ARG;
}
ss = esolver->options[LIS_EOPTIONS_SUBSPACE];
lis_vector_set_size(v,0,ss);
lis_vector_get_size(v,&n,&gn);
lis_vector_get_range(v,&is,&ie);
for(i=0;i<n;i++)
{
ii=i;
if( v->origin ) ii++;
lis_vector_set_value(LIS_INS_VALUE,ii+is,esolver->iter[i+is],v);
}
v->intvalue = 1;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LisVector::LisVector(std::size_t length, double* data)
{
lis_vector_create(0, &_vec);
lis_vector_set_size(_vec, 0, length);
for (std::size_t i = 0; i < length; i++)
lis_vector_set_value(LIS_INS_VALUE, i, data[i], _vec);
}
LIS_INT lis_gmres_malloc_work(LIS_SOLVER solver)
{
LIS_VECTOR *work;
LIS_INT i,j,restart,worklen,err;
LIS_DEBUG_FUNC_IN;
restart = solver->options[LIS_OPTIONS_RESTART];
worklen = NWORK + (restart+1);
work = (LIS_VECTOR *)lis_malloc( worklen*sizeof(LIS_VECTOR),"lis_gmres_malloc_work::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_ERR_OUT_OF_MEMORY;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
for(i=1;i<worklen;i++)
{
err = lis_vector_duplicate(solver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=1;i<worklen;i++)
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&work[i]);
if( err ) break;
memset(work[i]->value_lo,0,solver->A->np*sizeof(LIS_SCALAR));
}
}
if( i<worklen )
{
for(j=1;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
lis_vector_create(solver->A->comm,&work[0]);
}
else
{
lis_vector_createex(LIS_PRECISION_QUAD,solver->A->comm,&work[0]);
}
lis_vector_set_size(work[0],restart+1,0);
solver->worklen = worklen;
solver->work = work;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_input_vector_plain(LIS_VECTOR v, FILE *file)
{
char buf[BUFSIZE];
LIS_INT i;
LIS_INT err;
LIS_INT n,is,ie;
LIS_SCALAR val;
/* check size */
n = 0;
do
{
#ifdef _LONG__DOUBLE
err = fscanf(file, "%Lg", &val);
#else
err = fscanf(file, "%lg", &val);
#endif
if( err==1 ) n++;
}while( err==1 );
rewind(file);
/* read data */
err = lis_vector_set_size(v,0,n);
if( err )
{
return err;
}
lis_vector_get_range(v,&is,&ie);
for(i=0;i<n;i++)
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
if( i>=is && i<ie )
{
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%Lg", &val) != 1 )
#else
if( sscanf(buf, "%lg", &val) != 1 )
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
v->value[i-is] = val;
}
}
return LIS_SUCCESS;
}
void lis_vector_set_size_f(LIS_VECTOR_F *vec, LIS_INT *local_n, LIS_INT *global_n, LIS_INT *ierr)
{
LIS_VECTOR v;
LIS_DEBUG_FUNC_IN;
*ierr = lis_vector_set_size((LIS_VECTOR)LIS_V2P(vec),*local_n,*global_n);
if( *ierr ) return;
LIS_DEBUG_FUNC_OUT;
return;
}
/*! \fn allocate memory for linear system solver Lis
*
*/
int
allocateLisData(int n_row, int n_col, int nz, void** voiddata)
{
DATA_LIS* data = (DATA_LIS*) malloc(sizeof(DATA_LIS));
char buffer[128];
assertStreamPrint(NULL, 0 != data, "Could not allocate data for linear solver Lis.");
data->n_col = n_col;
data->n_row = n_row;
data->nnz = nz;
lis_vector_create(LIS_COMM_WORLD, &(data->b));
lis_vector_set_size(data->b, data->n_row, 0);
lis_vector_create(LIS_COMM_WORLD, &(data->x));
lis_vector_set_size(data->x, data->n_row, 0);
lis_matrix_create(LIS_COMM_WORLD, &(data->A));
lis_matrix_set_size(data->A, data->n_row, 0);
lis_matrix_set_type(data->A, LIS_MATRIX_CSR);
lis_solver_create(&(data->solver));
lis_solver_set_option("-print none", data->solver);
sprintf(buffer,"-maxiter %d", n_row*100);
lis_solver_set_option(buffer, data->solver);
lis_solver_set_option("-scale none", data->solver);
lis_solver_set_option("-p none", data->solver);
lis_solver_set_option("-initx_zeros 0", data->solver);
lis_solver_set_option("-tol 1.0e-12", data->solver);
data->work = (double*) calloc(n_col,sizeof(double));
rt_ext_tp_tick(&(data->timeClock));
*voiddata = (void*)data;
return 0;
}
/// initialize this object
void LisMPIDiscreteVector::initialize(MPI_Comm comm, int n_local, int n_global, size_t n_ghost)
{
MPI_Comm_rank(comm, &_local_id);
int err = lis_vector_create(comm, &_v);
err = lis_vector_set_size(_v, n_local, n_global);
err = lis_vector_get_size(_v, &_local_n, &_global_n);
err = lis_vector_get_range(_v, &_i_start, &_i_end);
CHKERR(err);
DiscreteVector::resize(_local_n+n_ghost);
_temp_all_x.resize(_global_n); //allocate temporary buffer
_list_index.resize(_local_n);
for (int i=0; i<_local_n; i++)
_list_index[i] = _i_start + i;
std::cout << _local_id << ": start=" << _i_start << ", end=" << _i_end << std::endl;
}
LIS_INT lis_input_vector_lis_ascii(LIS_VECTOR v, FILE *file)
{
LIS_INT n,nprocs,my_rank,pe;
LIS_INT err;
LIS_INT ibuf[10];
char cbuf[BUFSIZE];
char c;
LIS_Comm comm;
comm = v->comm;
#ifdef USE_MPI
MPI_Comm_size(comm,&nprocs);
MPI_Comm_rank(comm,&my_rank);
#else
nprocs = 1;
my_rank = 0;
#endif
if( fgets(cbuf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
if( sscanf(cbuf, "%lld",&ibuf[0])!=1 )
#else
if( sscanf(cbuf, "%d",&ibuf[0])!=1 )
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
if( nprocs!=ibuf[0] )
{
#ifdef _LONGLONG
LIS_SETERR2(LIS_ERR_FILE_IO,"The number of PE=(%lld) is different (in file PE=%lld)\n",nprocs,ibuf[0]);
#else
LIS_SETERR2(LIS_ERR_FILE_IO,"The number of PE=(%d) is different (in file PE=%d)\n",nprocs,ibuf[0]);
#endif
return LIS_ERR_FILE_IO;
}
pe=-1;
do
{
if( fgets(cbuf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
if( cbuf[0]=='#' )
{
#ifdef _LONGLONG
if( sscanf(cbuf, "%c %lld %lld",&c, &pe, &ibuf[1])!=3 )
#else
if( sscanf(cbuf, "%c %d %d",&c, &pe, &ibuf[1])!=3 )
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
}
}while(pe!=my_rank);
n = ibuf[1];
err = lis_vector_set_size(v,0,n);
if( err )
{
return err;
}
err = lis_fscan_scalar(n,file,v->value);
if( err )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
return LIS_SUCCESS;
}
LIS_INT lis_input_vector_mm(LIS_VECTOR v, FILE *file)
{
char buf[BUFSIZE];
char banner[64], mtx[64], fmt[64], dtype[64], dstruct[64];
char *p;
LIS_INT i;
LIS_INT err;
LIS_INT n,is,ie;
LIS_INT idx;
LIS_SCALAR val;
/* check banner */
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
sscanf(buf, "%s %s %s %s %s", banner, mtx, fmt, dtype, dstruct);
for(p=mtx;*p!='\0';p++) *p = (char)tolower(*p);
for(p=fmt;*p!='\0';p++) *p = (char)tolower(*p);
for(p=dtype;*p!='\0';p++) *p = (char)tolower(*p);
for(p=dstruct;*p!='\0';p++) *p = (char)tolower(*p);
if( strncmp(banner, MM_BANNER, strlen(MM_BANNER))!=0 || strncmp(mtx, MM_VEC, strlen(MM_VEC))!=0 )
{
LIS_SETERR(LIS_ERR_FILE_IO,"Not Matrix Market banner\n");
return LIS_ERR_FILE_IO;
}
if( strncmp(fmt, MM_FMT, strlen(MM_FMT))!=0 )
{
LIS_SETERR(LIS_ERR_FILE_IO,"Not Coodinate format\n");
return LIS_ERR_FILE_IO;
}
if( strncmp(dtype, MM_TYPE_REAL, strlen(MM_TYPE_REAL))!=0 )
{
LIS_SETERR(LIS_ERR_FILE_IO,"Not real\n");
return LIS_ERR_FILE_IO;
}
if( strncmp(dstruct, MM_TYPE_GENERAL, strlen(MM_TYPE_GENERAL))!=0 )
{
LIS_SETERR(LIS_ERR_FILE_IO,"Not general\n");
return LIS_ERR_FILE_IO;
}
/* check size */
do
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
}while( buf[0]=='%' );
#ifdef _LONGLONG
if( sscanf(buf, "%lld", &n) != 1 )
#else
if( sscanf(buf, "%d", &n) != 1 )
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
/* read data */
err = lis_vector_set_size(v,0,n);
if( err )
{
return err;
}
lis_vector_get_range(v,&is,&ie);
for(i=0;i<n;i++)
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%lld %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%lld %lg", &idx, &val) != 2 )
#endif
#else
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%d %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%d %lg", &idx, &val) != 2 )
#endif
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
idx--;
if( idx>=is && idx<ie )
{
v->value[idx-is] = val;
}
}
return LIS_SUCCESS;
}
LisVector::LisVector(std::size_t length)
{
lis_vector_create(0, &_vec);
lis_vector_set_size(_vec, 0, length);
}
LIS_INT lis_input_mm_vec(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, FILE *file, LIS_INT isb, LIS_INT isx, LIS_INT isbin)
{
char buf[BUFSIZE];
LIS_INT i;
LIS_INT mode;
LIS_INT gn,n,is,ie;
LIS_INT idx;
LIS_SCALAR val;
LIS_MM_VECFMT vecfmt;
LIS_DEBUG_FUNC_IN;
if( isb==0 && isx==0 ) return LIS_SUCCESS;
gn = A->gn;
n = A->n;
is = A->is;
ie = A->ie;
mode = 1;
mode = *(char *)&mode;
if( mode!=(isbin-1) )
{
mode = LIS_TRUE;
}
else
{
mode = LIS_FALSE;
}
if( isb )
{
lis_vector_set_size(b,n,0);
for(i=0;i<gn;i++)
{
if( isbin )
{
if( fread(&vecfmt, sizeof(vecfmt), 1, file)!=1 )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
idx = vecfmt.i;
val = vecfmt.value;
if( mode )
{
lis_bswap_int(1,&idx);
lis_bswap_scalar(1,&val);
}
}
else
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%lld %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%lld %lg", &idx, &val) != 2 )
#endif
#else
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%d %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%d %lg", &idx, &val) != 2 )
#endif
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
}
idx--;
if( idx>=is && idx<ie )
{
b->value[idx-is] = val;
}
}
}
if( isx )
{
lis_vector_set_size(x,n,0);
for(i=0;i<gn;i++)
{
if( isbin )
{
if( fread(&vecfmt, sizeof(vecfmt), 1, file)!=1 )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
idx = vecfmt.i;
val = vecfmt.value;
if( mode )
{
lis_bswap_int(1,&idx);
lis_bswap_scalar(1,&val);
}
}
else
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%lld %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%lld %lg", &idx, &val) != 2 )
#endif
#else
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%d %Lg", &idx, &val) != 2 )
#else
if( sscanf(buf, "%d %lg", &idx, &val) != 2 )
#endif
#endif
{
LIS_SETERR_FIO;
return LIS_ERR_FILE_IO;
}
}
idx--;
if( idx>=is && idx<ie )
{
x->value[idx-is] = val;
}
}
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
