/* ////////////////////////////////////////////////////////////////////////////
-- Debugging file
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_d_solver_par solver_par;
magma_d_preconditioner precond_par;
solver_par.epsilon = 10e-16;
solver_par.maxiter = 1000;
solver_par.verbose = 0;
precond_par.solver = Magma_JACOBI;
magma_dsolverinfo_init( &solver_par, &precond_par );
double one = MAGMA_D_MAKE(1.0, 0.0);
double zero = MAGMA_D_MAKE(0.0, 0.0);
magma_d_sparse_matrix A, B, B_d;
magma_d_vector x, b;
// generate matrix of desired structure and size
magma_int_t n=10; // size is n*n
magma_int_t nn = n*n;
magma_int_t offdiags = 2;
magma_index_t *diag_offset;
double *diag_vals;
magma_dmalloc_cpu( &diag_vals, offdiags+1 );
magma_index_malloc_cpu( &diag_offset, offdiags+1 );
diag_offset[0] = 0;
diag_offset[1] = 1;
diag_offset[2] = n;
diag_vals[0] = MAGMA_D_MAKE( 4.0, 0.0 );
diag_vals[1] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[2] = MAGMA_D_MAKE( -1.0, 0.0 );
magma_dmgenerator( nn, offdiags, diag_offset, diag_vals, &A );
// convert marix into desired format
B.storage_type = Magma_SELLC;
B.blocksize = 8;
B.alignment = 8;
// scale matrix
magma_dmscale( &A, Magma_UNITDIAG );
magma_d_mconvert( A, &B, Magma_CSR, B.storage_type );
magma_d_mtransfer( B, &B_d, Magma_CPU, Magma_DEV );
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
// solver
magma_dpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_mfree(&B_d);
magma_d_mfree(&B);
magma_d_mfree(&A);
magma_d_vfree(&x);
magma_d_vfree(&b);
TESTING_FINALIZE();
return 0;
}
magma_int_t
magma_dinitguess(
magma_d_matrix A,
magma_d_matrix *L,
magma_d_matrix *U,
magma_queue_t queue )
{
magma_int_t info = 0;
double one = MAGMA_D_MAKE( 1.0, 0.0 );
magma_d_matrix hAL={Magma_CSR}, hAU={Magma_CSR}, dAL={Magma_CSR},
dAU={Magma_CSR}, dALU={Magma_CSR}, hALU={Magma_CSR}, hD={Magma_CSR},
dD={Magma_CSR}, dL={Magma_CSR}, hL={Magma_CSR};
magma_int_t i,j;
magma_int_t offdiags = 0;
magma_index_t *diag_offset;
double *diag_vals=NULL;
// need only lower triangular
hAL.diagorder_type = Magma_VALUE;
CHECK( magma_dmconvert( A, &hAL, Magma_CSR, Magma_CSRL, queue ));
//magma_dmconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO );
// need only upper triangular
//magma_dmconvert( A, &hAU, Magma_CSR, Magma_CSRU );
CHECK( magma_d_cucsrtranspose( hAL, &hAU, queue ));
//magma_dmconvert( hAU, &hAUCOO, Magma_CSR, Magma_CSRCOO );
CHECK( magma_dmtransfer( hAL, &dAL, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_d_spmm( one, dAL, dAU, &dALU, queue ));
CHECK( magma_dmtransfer( dALU, &hALU, Magma_DEV, Magma_CPU, queue ));
magma_dmfree( &dAU, queue);
magma_dmfree( &dALU, queue);
CHECK( magma_dmalloc_cpu( &diag_vals, offdiags+1 ));
CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 ));
diag_offset[0] = 0;
diag_vals[0] = MAGMA_D_MAKE( 1.0, 0.0 );
CHECK( magma_dmgenerator( hALU.num_rows, offdiags, diag_offset, diag_vals, &hD, queue ));
magma_dmfree( &hALU, queue );
for(i=0; i<hALU.num_rows; i++){
for(j=hALU.row[i]; j<hALU.row[i+1]; j++){
if( hALU.col[j] == i ){
//printf("%d %d %d == %d -> %f -->", i, j, hALU.col[j], i, hALU.val[j]);
hD.val[i] = MAGMA_D_MAKE(
1.0 / sqrt(fabs(MAGMA_D_REAL(hALU.val[j]))) , 0.0 );
//printf("insert %f at %d\n", hD.val[i], i);
}
}
}
CHECK( magma_dmtransfer( hD, &dD, Magma_CPU, Magma_DEV, queue ));
magma_dmfree( &hD, queue);
CHECK( magma_d_spmm( one, dD, dAL, &dL, queue ));
magma_dmfree( &dAL, queue );
magma_dmfree( &dD, queue );
/*
// check for diagonal = 1
magma_d_matrix dLt={Magma_CSR}, dLL={Magma_CSR}, LL={Magma_CSR};
CHECK( magma_d_cucsrtranspose( dL, &dLt ));
CHECK( magma_dcuspmm( dL, dLt, &dLL ));
CHECK( magma_dmtransfer( dLL, &LL, Magma_DEV, Magma_CPU ));
//for(i=0; i < hALU.num_rows; i++) {
for(i=0; i < 100; i++) {
for(j=hALU.row[i]; j < hALU.row[i+1]; j++) {
if( hALU.col[j] == i ){
printf("%d %d -> %f -->", i, i, LL.val[j]);
}
}
}
*/
CHECK( magma_dmtransfer( dL, &hL, Magma_DEV, Magma_CPU, queue ));
CHECK( magma_dmconvert( hL, L, Magma_CSR, Magma_CSRCOO, queue ));
cleanup:
if( info !=0 ){
magma_dmfree( L, queue );
magma_dmfree( U, queue );
}
magma_dmfree( &dAU, queue);
magma_dmfree( &dALU, queue);
magma_dmfree( &dL, queue );
magma_dmfree( &hL, queue );
magma_dmfree( &dAL, queue );
magma_dmfree( &dD, queue );
magma_dmfree( &hD, queue);
magma_dmfree( &hALU, queue );
return info;
}
magma_int_t
magma_dm_5stencil(
magma_int_t n,
magma_d_matrix *A,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_int_t i,j,k;
magma_d_matrix hA={Magma_CSR};
// generate matrix of desired structure and size (2d 5-point stencil)
magma_int_t nn = n*n;
magma_int_t offdiags = 2;
magma_index_t *diag_offset=NULL;
double *diag_vals=NULL;
CHECK( magma_dmalloc_cpu( &diag_vals, offdiags+1 ));
CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 ));
diag_offset[0] = 0;
diag_offset[1] = 1;
diag_offset[2] = n;
#define REAL
#ifdef COMPLEX
// real case
diag_vals[0] = MAGMA_D_MAKE( 4.0, 4.0 );
diag_vals[1] = MAGMA_D_MAKE( -1.0, -1.0 );
diag_vals[2] = MAGMA_D_MAKE( -1.0, -1.0 );
#else
// real case
diag_vals[0] = MAGMA_D_MAKE( 4.0, 0.0 );
diag_vals[1] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[2] = MAGMA_D_MAKE( -1.0, 0.0 );
#endif
CHECK( magma_dmgenerator( nn, offdiags, diag_offset, diag_vals, &hA, queue ));
// now set some entries to zero (boundary...)
for( i=0; i<n; i++ ) {
for( j=0; j<n; j++ ) {
magma_index_t row = i*n+j;
for( k=hA.row[row]; k<hA.row[row+1]; k++) {
if ((hA.col[k] == row-1 ) && (row+1)%n == 1 )
hA.val[k] = MAGMA_D_MAKE( 0.0, 0.0 );
if ((hA.col[k] == row+1 ) && (row)%n ==n-1 )
hA.val[k] = MAGMA_D_MAKE( 0.0, 0.0 );
}
}
}
CHECK( magma_dmconvert( hA, A, Magma_CSR, Magma_CSR, queue ));
magma_dmcsrcompressor( A, queue );
A->true_nnz = A->nnz;
cleanup:
magma_free_cpu( diag_vals );
magma_free_cpu( diag_offset );
magma_dmfree( &hA, queue );
return info;
}
/* ////////////////////////////////////////////////////////////////////////////
-- Debugging file
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_d_solver_par solver_par;
magma_d_preconditioner precond_par;
solver_par.epsilon = 10e-16;
solver_par.maxiter = 1000;
solver_par.verbose = 0;
solver_par.restart = 30;
solver_par.num_eigenvalues = 0;
solver_par.ortho = Magma_CGS;
double one = MAGMA_D_MAKE(1.0, 0.0);
double zero = MAGMA_D_MAKE(0.0, 0.0);
magma_d_sparse_matrix A, B, B_d;
magma_d_vector x, b;
// generate matrix of desired structure and size
magma_int_t n=100; // size is n*n
magma_int_t nn = n*n;
magma_int_t offdiags = 2;
magma_index_t *diag_offset;
double *diag_vals;
magma_dmalloc_cpu( &diag_vals, offdiags+1 );
magma_index_malloc_cpu( &diag_offset, offdiags+1 );
diag_offset[0] = 0;
diag_offset[1] = 1;
diag_offset[2] = n;
diag_vals[0] = MAGMA_D_MAKE( 4.1, 0.0 );
diag_vals[1] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[2] = MAGMA_D_MAKE( -1.0, 0.0 );
magma_dmgenerator( nn, offdiags, diag_offset, diag_vals, &A );
// convert marix into desired format
B.storage_type = Magma_SELLC;
B.blocksize = 8;
B.alignment = 8;
// scale matrix
magma_dmscale( &A, Magma_UNITDIAG );
magma_d_mconvert( A, &B, Magma_CSR, B.storage_type );
magma_d_mtransfer( B, &B_d, Magma_CPU, Magma_DEV );
// test CG ####################################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// solver
magma_dcg_res( B_d, b, &x, &solver_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PCG Jacobi ############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PCG IC ################################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ICC;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PCG IC ################################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ICC;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test BICGSTAB ####################################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// solver
magma_dbicgstab( B_d, b, &x, &solver_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PBICGSTAB Jacobi ############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
/*
// test PBICGSTAB ILU ###############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PBICGSTAB ILU ###############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);printf("here\n");
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test GMRES ####################################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// solver
magma_dgmres( B_d, b, &x, &solver_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
// test PGMRES Jacobi ############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpgmres( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);*/
// test PGMRES ILU ###############################
// vectors and initial guess
magma_d_vinit( &b, Magma_DEV, A.num_cols, one );
magma_d_vinit( &x, Magma_DEV, A.num_cols, one );
magma_d_spmv( one, B_d, x, zero, b ); // b = A x
magma_d_vfree(&x);
magma_d_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_dsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_d_precondsetup( B_d, b, &precond_par );
// solver
magma_dpgmres( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_dsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_vfree(&x);
magma_d_vfree(&b);
printf("all tests passed.\n");
magma_d_mfree(&B_d);
magma_d_mfree(&B);
magma_d_mfree(&A);
TESTING_FINALIZE();
return 0;
}
magma_int_t
magma_dm_27stencil(
magma_int_t n,
magma_d_matrix *A,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_int_t i,j,k;
magma_d_matrix hA={Magma_CSR};
// generate matrix of desired structure and size (3d 27-point stencil)
magma_int_t nn = n*n*n;
magma_int_t offdiags = 13;
magma_index_t *diag_offset=NULL;
double *diag_vals=NULL;
CHECK( magma_dmalloc_cpu( &diag_vals, offdiags+1 ));
CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 ));
diag_offset[0] = 0;
diag_offset[1] = 1;
diag_offset[2] = n-1;
diag_offset[3] = n;
diag_offset[4] = n+1;
diag_offset[5] = n*n-n-1;
diag_offset[6] = n*n-n;
diag_offset[7] = n*n-n+1;
diag_offset[8] = n*n-1;
diag_offset[9] = n*n;
diag_offset[10] = n*n+1;
diag_offset[11] = n*n+n-1;
diag_offset[12] = n*n+n;
diag_offset[13] = n*n+n+1;
diag_vals[0] = MAGMA_D_MAKE( 26.0, 0.0 );
diag_vals[1] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[2] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[3] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[4] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[5] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[6] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[7] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[8] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[9] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[10] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[11] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[12] = MAGMA_D_MAKE( -1.0, 0.0 );
diag_vals[13] = MAGMA_D_MAKE( -1.0, 0.0 );
CHECK( magma_dmgenerator( nn, offdiags, diag_offset, diag_vals, &hA, queue ));
// now set some entries to zero (boundary...)
for( i=0; i < n*n; i++ ) {
for( j=0; j < n; j++ ) {
magma_index_t row = i*n+j;
for( k=hA.row[row]; k<hA.row[row+1]; k++) {
if ((hA.col[k] == row-1 ||
hA.col[k] == row-n-1 ||
hA.col[k] == row+n-1 ||
hA.col[k] == row-n*n+n-1 ||
hA.col[k] == row+n*n-n-1 ||
hA.col[k] == row-n*n-1 ||
hA.col[k] == row+n*n-1 ||
hA.col[k] == row-n*n-n-1 ||
hA.col[k] == row+n*n+n-1 ) && (row+1)%n == 1 )
hA.val[k] = MAGMA_D_MAKE( 0.0, 0.0 );
if ((hA.col[k] == row+1 ||
hA.col[k] == row-n+1 ||
hA.col[k] == row+n+1 ||
hA.col[k] == row-n*n+n+1 ||
hA.col[k] == row+n*n-n+1 ||
hA.col[k] == row-n*n+1 ||
hA.col[k] == row+n*n+1 ||
hA.col[k] == row-n*n-n+1 ||
hA.col[k] == row+n*n+n+1 ) && (row)%n ==n-1 )
hA.val[k] = MAGMA_D_MAKE( 0.0, 0.0 );
}
}
}
hA.true_nnz = hA.nnz;
CHECK( magma_dmconvert( hA, A, Magma_CSR, Magma_CSR, queue ));
cleanup:
magma_free_cpu( diag_vals );
magma_free_cpu( diag_offset );
magma_dmfree( &hA, queue );
return info;
}
