int lis_vector_set_size(LIS_VECTOR vec, int local_n, int global_n)
{
int nprocs,my_rank;
int is,ie;
int i,err,precision;
int *ranges;
LIS_DEBUG_FUNC_IN;
if( global_n>0 && local_n>global_n )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) is larger than global n(=%d)\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n<0 || global_n<0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) or global n(=%d) are less than 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n==0 && global_n==0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) and global n(=%d) are 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
err = lis_ranges_create(vec->comm,&local_n,&global_n,&ranges,&is,&ie,&nprocs,&my_rank);
if( err )
{
return err;
}
vec->ranges = ranges;
precision = vec->precision;
if( !precision )
{
vec->value = (LIS_SCALAR *)lis_malloc( local_n*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->value" );
if( NULL==vec->value )
{
LIS_SETERR_MEM(local_n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<local_n;i++)
{
vec->value[i] = 0.0;
}
}
else
{
vec->value = (LIS_SCALAR *)lis_malloc( (2*local_n + local_n%2)*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->value" );
if( NULL==vec->value )
{
LIS_SETERR_MEM((2*local_n+local_n%2)*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
vec->value_lo = vec->value + local_n + local_n%2;
vec->work = (LIS_SCALAR *)lis_malloc( 32*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->work" );
if( NULL==vec->work )
{
LIS_SETERR_MEM(32*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<local_n;i++)
{
vec->value[i] = 0.0;
vec->value_lo[i] = 0.0;
}
}
vec->is_copy = LIS_TRUE;
vec->status = LIS_VECTOR_ASSEMBLED;
vec->n = local_n;
vec->gn = global_n;
vec->np = local_n;
vec->my_rank = my_rank;
vec->nprocs = nprocs;
vec->is = is;
vec->ie = ie;
vec->origin = LIS_ORIGIN_0;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_set_size(LIS_VECTOR vec, LIS_INT local_n, LIS_INT global_n)
{
LIS_INT nprocs,my_rank;
LIS_INT is,ie;
LIS_INT i,err,precision;
LIS_INT *ranges;
LIS_DEBUG_FUNC_IN;
if( global_n>0 && local_n>global_n )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) is larger than global n(=%d)\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n<0 || global_n<0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) or global n(=%d) are less than 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
/* the condition (local_n=0 and global_n=0) deleted, as it is now allowed . . . */
/* satisfaction of that condition implies that local sizes were specified, and the */
/* local size on the current process is zero */
err = lis_ranges_create(vec->comm,&local_n,&global_n,&ranges,&is,&ie,&nprocs,&my_rank);
if( err )
{
return err;
}
vec->ranges = ranges;
precision = vec->precision;
if( !precision )
{
vec->value = (LIS_SCALAR *)lis_malloc( local_n*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->value" );
if( NULL==vec->value )
{
LIS_SETERR_MEM(local_n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<local_n;i++)
{
vec->value[i] = 0.0;
}
}
else
{
vec->value = (LIS_SCALAR *)lis_malloc( (2*local_n + local_n%2)*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->value" );
if( NULL==vec->value )
{
LIS_SETERR_MEM((2*local_n+local_n%2)*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
vec->value_lo = vec->value + local_n + local_n%2;
vec->work = (LIS_SCALAR *)lis_malloc( 32*sizeof(LIS_SCALAR),"lis_vector_set_size::vec->work" );
if( NULL==vec->work )
{
LIS_SETERR_MEM(32*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<local_n;i++)
{
vec->value[i] = 0.0;
vec->value_lo[i] = 0.0;
}
}
vec->is_copy = LIS_TRUE;
vec->status = LIS_VECTOR_ASSEMBLED;
vec->n = local_n;
vec->gn = global_n;
vec->np = local_n;
vec->my_rank = my_rank;
vec->nprocs = nprocs;
vec->is = is;
vec->ie = ie;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_matrix_create_rco(LIS_INT local_n, LIS_INT global_n, LIS_Comm comm, LIS_INT annz, LIS_INT *nnz, LIS_MATRIX *Amat)
{
LIS_INT nprocs,my_rank;
LIS_INT is,ie,err;
LIS_INT i,k;
LIS_INT *ranges;
LIS_DEBUG_FUNC_IN;
*Amat = NULL;
if( global_n>0 && local_n>global_n )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) is larger than global n(=%d)\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n<0 || global_n<0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) or global n(=%d) are less than 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n==0 && global_n==0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) and global n(=%d) are 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
*Amat = (LIS_MATRIX)lis_malloc( sizeof(struct LIS_MATRIX_STRUCT),"lis_matrix_create_rco::Amat" );
if( NULL==*Amat )
{
LIS_SETERR_MEM(sizeof(struct LIS_MATRIX_STRUCT));
return LIS_OUT_OF_MEMORY;
}
lis_matrix_init(Amat);
err = lis_ranges_create(comm,&local_n,&global_n,&ranges,&is,&ie,&nprocs,&my_rank);
if( err )
{
lis_matrix_destroy(*Amat);
*Amat = NULL;
return err;
}
(*Amat)->ranges = ranges;
(*Amat)->w_nnz = (LIS_INT *)lis_malloc(local_n*sizeof(LIS_INT),"lis_matrix_create_rco::Amat->w_nnz");
if( (*Amat)->w_nnz==NULL )
{
LIS_SETERR_MEM(local_n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
if( nnz==NULL )
{
(*Amat)->w_annz = annz;
for(k=0;k<local_n;k++) (*Amat)->w_nnz[k] = (*Amat)->w_annz;
}
else
{
i = 0;
for(k=0;k<local_n;k++)
{
(*Amat)->w_nnz[k] = nnz[k];
i += nnz[k];
}
(*Amat)->w_annz = i/local_n;
}
err = lis_matrix_malloc_rco(local_n,(*Amat)->w_nnz,&(*Amat)->w_row,&(*Amat)->w_index,&(*Amat)->w_value);
if( err )
{
lis_free((*Amat)->w_nnz);
return err;
}
(*Amat)->status = LIS_MATRIX_ASSEMBLING;
(*Amat)->n = local_n;
(*Amat)->gn = global_n;
(*Amat)->np = local_n;
(*Amat)->comm = comm;
(*Amat)->my_rank = my_rank;
(*Amat)->nprocs = nprocs;
(*Amat)->is = is;
(*Amat)->ie = ie;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
