int lis_vector_scatter(LIS_SCALAR value[], LIS_VECTOR v)
{
#ifdef USE_MPI
int err,i,is,n,my_rank,nprocs,*sendcounts;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
my_rank = v->my_rank;
nprocs = v->nprocs;
n = v->n;
is = v->is;
sendcounts = (int *)lis_malloc( (nprocs+1)*sizeof(int),"lis_vector_scatter::sendcounts" );
for(i=0; i<nprocs; i++)
{
sendcounts[i] = v->ranges[i+1] - v->ranges[i];
}
MPI_Scatterv(&value[0],sendcounts,v->ranges,MPI_DOUBLE,&value[is],n,MPI_DOUBLE,0,v->comm);
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0; i<n; i++)
{
v->value[i] = value[i+is];
}
return LIS_SUCCESS;
#else
int err,i,n;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
n = v->n;
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0; i<n; i++)
{
v->value[i] = value[i];
}
return LIS_SUCCESS;
#endif
}
LIS_INT lis_vector_gather(LIS_VECTOR v, LIS_SCALAR value[])
{
#ifdef USE_MPI
LIS_INT err,i,is,n,nprocs,*recvcounts;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
nprocs = v->nprocs;
n = v->n;
is = v->is;
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0; i<n; i++)
{
value[i+is] = v->value[i];
}
recvcounts = (LIS_INT *)lis_malloc( (nprocs+1)*sizeof(LIS_INT),"lis_vector_gather::recvcounts" );
for(i=0; i<nprocs; i++)
{
recvcounts[i] = v->ranges[i+1] - v->ranges[i];
}
MPI_Allgatherv(&value[is],n,MPI_DOUBLE,&value[0],recvcounts,v->ranges,MPI_DOUBLE,v->comm);
return LIS_SUCCESS;
#else
LIS_INT err,i,n;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
n = v->n;
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0; i<n; i++)
{
value[i] = v->value[i];
}
return LIS_SUCCESS;
#endif
}
int lis_vector_print(LIS_VECTOR x)
{
#ifdef USE_MPI
int err,i,ii,is,n,k,nprocs,my_rank;
err = lis_vector_check(x,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
nprocs = x->nprocs;
my_rank = x->my_rank;
n = x->n;
is = x->is;
for(k=0;k<nprocs;k++)
{
if( k==my_rank )
{
for(i=0;i<n;i++)
{
ii = i+is;
if( x->origin ) ii++;
printf("%6d %e\n",ii,x->value[i]);
}
}
MPI_Barrier(x->comm);
}
return LIS_SUCCESS;
#else
int err,i,ii,n;
err = lis_vector_check(x,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
n = x->n;
for(i=0; i<n; i++)
{
ii = i;
if( x->origin ) ii++;
if( x->precision==LIS_PRECISION_DEFAULT )
{
printf("%6d %e\n",ii,x->value[i]);
}
else
{
printf("%6d %e,%e\n",ii,x->value[i],x->value_lo[i]);
}
}
return LIS_SUCCESS;
#endif
}
LIS_INT lis_vector_get_value(LIS_VECTOR v, LIS_INT i, LIS_SCALAR *value)
{
LIS_INT err,is,ie;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
is = v->is;
ie = v->ie;
if( v->origin ) i--;
if( i<is || i>=ie )
{
if( v->origin )
{
i++;
is++;
ie++;
}
LIS_SETERR3(LIS_ERR_ILL_ARG, "i(=%d) is less than %d or not less than %d\n",i,is,ie);
return LIS_ERR_ILL_ARG;
}
*value = v->value[i-is];
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_output_vector(LIS_VECTOR v, LIS_INT format, char *filename)
{
LIS_INT err;
LIS_DEBUG_FUNC_IN;
#ifdef USE_MPI
MPI_Barrier(v->comm);
#endif
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
switch( format )
{
case LIS_FMT_PLAIN:
err = lis_output_vector_plain(v,filename);
break;
case LIS_FMT_MM:
err = lis_output_vector_mm(v,filename);
break;
case LIS_FMT_LIS:
err = lis_output_vector_lis_ascii(v,filename);
break;
default:
LIS_SETERR(LIS_ERR_ILL_ARG,"ill format option\n");
return LIS_ERR_ILL_ARG;
break;
}
LIS_DEBUG_FUNC_OUT;
return err;
}
LIS_INT lis_vector_reuse(LIS_VECTOR *vec)
{
LIS_INT err,np,precision;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(*vec,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
np = (*vec)->np;
if( (*vec)->status==LIS_VECTOR_NULL )
{
precision = ((LIS_VECTOR)*vec)->precision;
if( !precision )
{
(*vec)->value = (LIS_SCALAR *)lis_malloc( np*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->value" );
if( NULL==(*vec)->value )
{
LIS_SETERR_MEM(np*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
(*vec)->is_copy = LIS_TRUE;
}
else
{
(*vec)->value = (LIS_SCALAR *)lis_malloc( (2*np+np%2)*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->value" );
if( NULL==(*vec)->value )
{
LIS_SETERR_MEM((2*np+np%2)*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
(*vec)->is_copy = LIS_TRUE;
(*vec)->value_lo = (*vec)->value + np + np%2;
(*vec)->work = (LIS_SCALAR *)lis_malloc( 32*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->work" );
if( NULL==(*vec)->work )
{
LIS_SETERR_MEM(32*sizeof(LIS_SCALAR));
lis_vector_destroy(*vec);
*vec = NULL;
return LIS_OUT_OF_MEMORY;
}
}
}
(*vec)->status = LIS_VECTOR_ASSEMBLED;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_get_range(LIS_VECTOR v, LIS_INT *is, LIS_INT *ie)
{
LIS_INT err;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
*is = v->is;
*ie = v->ie;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_get_size(LIS_VECTOR v, LIS_INT *local_n, LIS_INT *global_n)
{
LIS_INT err;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
*local_n = v->n;
*global_n = v->gn;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_unset(LIS_VECTOR vec)
{
LIS_INT err;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(vec,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
if( vec->is_copy ) lis_free(vec->value);
vec->value = NULL;
vec->status = LIS_VECTOR_NULL;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_set(LIS_VECTOR vec, LIS_SCALAR *value)
{
LIS_INT err;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(vec,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
if( vec->is_destroy ) lis_free(vec->value);
vec->value = value;
vec->is_copy = LIS_FALSE;
vec->status = LIS_VECTOR_ASSEMBLING;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
int lis_vector_get_values(LIS_VECTOR v, int start, int count, LIS_SCALAR value[])
{
int err,n,gn,i,is,ie;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
n = v->n;
gn = v->gn;
is = v->is;
ie = v->ie;
if( v->origin ) start--;
if( start<is || start>=ie )
{
if( v->origin )
{
start++;
is++;
ie++;
}
LIS_SETERR3(LIS_ERR_ILL_ARG, "start(=%d) is less than %d or larger than %d\n",start,is,ie);
return LIS_ERR_ILL_ARG;
}
if( (start-is+count)>n )
{
LIS_SETERR3(LIS_ERR_ILL_ARG, "start(=%d) + count(=%d) exceeds the range of vector v(=%d).\n",start,count,ie);
return LIS_ERR_ILL_ARG;
}
for(i=0;i<count;i++)
{
value[i] = v->value[start-is + i];
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
int lis_vector_get_range(LIS_VECTOR v, int *is, int *ie)
{
int err;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(v,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
if( v->origin )
{
*is = v->is + 1;
*ie = v->ie + 1;
}
else
{
*is = v->is;
*ie = v->ie;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_input(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, char *filename)
{
LIS_INT err;
LIS_INT fileformat;
char buf[256],banner[128];
FILE *file;
LIS_DEBUG_FUNC_IN;
err = lis_matrix_check(A,LIS_MATRIX_CHECK_NULL);
if( err ) return err;
if( b!=NULL && x!=NULL )
{
err = lis_vector_check(b,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
err = lis_vector_check(x,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
}
if( filename==NULL )
{
LIS_SETERR(LIS_ERR_ILL_ARG,"filname is NULL\n");
return LIS_ERR_ILL_ARG;
}
file = fopen(filename, "r");
if( file==NULL )
{
LIS_SETERR1(LIS_ERR_FILE_IO,"cannot open file %s\n",filename);
return LIS_ERR_FILE_IO;
}
/* file format check */
if( fgets(buf, 256, file) == NULL )
{
fclose(file);
return LIS_ERR_FILE_IO;
}
sscanf(buf, "%s", banner);
if( strncmp(banner, MM_BANNER, strlen(MM_BANNER)) == 0)
{
fileformat = LIS_FMT_MM;
}
/* else if( strncmp(banner, LISBanner, strlen(LISBanner)) == 0)
{
fileformat = LIS_FMT_LIS;
}
else if( strncmp(banner, ITBLBanner, strlen(ITBLBanner)) == 0)
{
fileformat = LIS_FMT_ITBL;
}
*/
else
{
fileformat = LIS_FMT_HB;
}
rewind(file);
/*
if( fileformat==LIS_FMT_FREE )
{
fclose(file);
err = lis_input_option(&option, filename);
if( err ) return err;
file = fopen(option.filename, "r");
if( file==NULL )
{
LIS_SETERR1(LIS_ERR_FILE_IO,"cannot open file %s\n",filename);
return LIS_ERR_FILE_IO;
}
}
*/
switch( fileformat )
{
case LIS_FMT_MM:
err = lis_input_mm(A,b,x,file);
break;
case LIS_FMT_HB:
err = lis_input_hb(A,b,x,file);
break;
/*
case LIS_FMT_ITBL:
err = lis_input_mmm(A,b,x,file,comm,matrix_type,bnr,bnc,row,col);
break;
case LIS_FMT_LIS:
err = lis_input_lis(A,b,x,filename,file,comm,matrix_type,bnr,bnc,row,col);
break;
case LIS_FMT_FREE:
err = lis_input_free(A,b,x,option,file,comm,matrix_type,bnr,bnc,row,col);
break;
*/
default:
fclose(file);
return err;
}
fclose(file);
#ifdef USE_MPI
MPI_Barrier(A->comm);
#endif
LIS_DEBUG_FUNC_OUT;
return err;
}
