LIS_INT lis_esi_quad(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x, Ax;
LIS_SCALAR xAx, xx, mu, lshift;
LIS_INT ss;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT i,j,k;
LIS_SCALAR evalue,dotvr;
LIS_INT iter,giter,output,niesolver;
LIS_INT nprocs,my_rank;
LIS_REAL nrm2,dot,resid,resid0;
LIS_QUAD_PTR qdot_vv, qdot_vr;
LIS_VECTOR *v,r,q;
LIS_SOLVER solver;
LIS_PRECON precon;
double times,itimes,ptimes,p_c_times,p_i_times;
LIS_INT err;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
LIS_DEBUG_FUNC_IN;
A = esolver->A;
x = esolver->x;
ss = esolver->options[LIS_EOPTIONS_SUBSPACE];
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
lshift = esolver->lshift;
output = esolver->options[LIS_EOPTIONS_OUTPUT];
niesolver = esolver->options[LIS_EOPTIONS_INNER_ESOLVER];
r = esolver->work[0];
q = esolver->work[1];
v = &esolver->work[2];
Ax = esolver->work[3];
LIS_QUAD_SCALAR_MALLOC(qdot_vv,0,1);
LIS_QUAD_SCALAR_MALLOC(qdot_vr,1,1);
lis_vector_set_all(1.0,r);
lis_vector_nrm2(r, &nrm2);
lis_vector_scale(1/nrm2,r);
switch ( niesolver )
{
case LIS_ESOLVER_II:
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p ilu -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
break;
case LIS_ESOLVER_AII:
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p ilu -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
lis_vector_set_all(1.0,q);
lis_solve(A, q, x, solver);
lis_precon_create(solver, &precon);
solver->precon = precon;
break;
case LIS_ESOLVER_RQI:
lis_solver_create(&solver);
lis_solver_set_option("-p ilu -precision quad -maxiter 10",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
break;
}
giter=0;
j=0;
while (j<ss)
{
lis_vector_duplicate(A,&esolver->evector[j]);
j = j+1;
lis_vector_copy(r, v[j]);
if (niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_RQI)
{
/* create preconditioner */
solver->A = A;
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
}
if (niesolver==LIS_ESOLVER_RQI)
{
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
lis_matvec(A, x, Ax);
lis_vector_dot(x, Ax, &xAx);
lis_vector_dot(x, x, &xx);
mu = xAx / xx;
}
iter = 0;
while (iter<emaxiter)
{
/* diagonalization */
iter = iter+1;
giter = giter+1;
for (k=1;k<j;k++)
{
lis_vector_dotex_mmm(v[j], v[k], &qdot_vv);
lis_quad_minus((LIS_QUAD *)qdot_vv.hi);
lis_vector_axpyex_mmm(qdot_vv,v[k],v[j]);
}
switch( niesolver )
{
case LIS_ESOLVER_PI:
lis_matvec(A,v[j],r);
break;
case LIS_ESOLVER_II:
lis_solve_kernel(A, v[j], r, solver, precon);
break;
case LIS_ESOLVER_AII:
lis_psolve(solver, v[j], r);
break;
case LIS_ESOLVER_RQI:
lis_vector_nrm2(v[j], &nrm2);
lis_vector_scale(1/nrm2, v[j]);
lis_matrix_shift_diagonal(A, -mu);
lis_solve_kernel(A, v[j], r, solver, precon);
lis_matrix_shift_diagonal(A, mu);
break;
}
if ( j==1 && ( niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_AII || niesolver==LIS_ESOLVER_RQI ))
{
lis_solver_get_timeex(solver,×,&itimes,&ptimes,&p_c_times,&p_i_times);
esolver->ptimes += solver->ptimes;
esolver->itimes += solver->itimes;
esolver->p_c_times += solver->p_c_times;
esolver->p_i_times += solver->p_i_times;
}
lis_vector_nrm2(r, &nrm2);
lis_vector_dotex_mmm(v[j], r, &qdot_vr);
lis_quad_minus((LIS_QUAD *)qdot_vr.hi);
lis_vector_axpyzex_mmmm(qdot_vr,v[j],r,q);
lis_quad_minus((LIS_QUAD *)qdot_vr.hi);
dotvr = qdot_vr.hi[0];
mu = mu + 1/dotvr;
lis_vector_nrm2(q, &resid);
resid = fabs(resid / dotvr);
lis_vector_scale(1/nrm2,r);
lis_vector_copy(r, v[j]);
if ( j==1 )
{
if( output & LIS_PRINT_MEM ) esolver->residual[iter] = resid;
if( output & LIS_PRINT_OUT ) printf("iter: %5d residual = %e\n", iter, resid);
esolver->iter = iter;
esolver->resid = resid;
}
if (tol>resid) break;
}
if (niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_RQI)
{
lis_precon_destroy(precon);
}
switch ( niesolver )
{
case LIS_ESOLVER_PI:
esolver->evalue[j-1] = dotvr;
break;
case LIS_ESOLVER_II:
esolver->evalue[j-1] = 1/dotvr;
break;
case LIS_ESOLVER_AII:
esolver->evalue[j-1] = 1/dotvr;
break;
case LIS_ESOLVER_RQI:
esolver->evalue[j-1] = mu;
break;
}
lis_vector_copy(v[j], esolver->evector[j-1]);
if (A->my_rank==0 && ss>1)
{
#ifdef _LONGLONG
printf("Subspace: mode number = %lld\n", j-1);
#else
printf("Subspace: mode number = %d\n", j-1);
#endif
printf("Subspace: eigenvalue = %e\n", esolver->evalue[j-1]);
#ifdef _LONGLONG
printf("Subspace: number of iterations = %lld\n",iter);
#else
printf("Subspace: number of iterations = %d\n",iter);
#endif
printf("Subspace: relative residual 2-norm = %e\n",resid);
}
}
lis_vector_copy(esolver->evector[esolver->options[LIS_EOPTIONS_MODE]], esolver->x);
switch ( niesolver )
{
case LIS_ESOLVER_II:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_solver_destroy(solver);
break;
case LIS_ESOLVER_AII:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_precon_destroy(precon);
lis_solver_destroy(solver);
break;
case LIS_ESOLVER_RQI:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_solver_destroy(solver);
break;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_ecr(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x;
LIS_SCALAR evalue;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,i,j,output;
LIS_INT nprocs,my_rank;
LIS_REAL nrm2,resid;
LIS_SCALAR lshift;
LIS_VECTOR r,p,Ax,Ar,Ap;
LIS_SCALAR alpha, beta;
LIS_SCALAR rAp, rp, ApAp, pAp, pp, ArAp, pAr;
double times,itimes,ptimes,p_c_times,p_i_times;
A = esolver->A;
x = esolver->x;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
output = esolver->options[LIS_EOPTIONS_OUTPUT];
lshift = esolver->lshift;
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
r = esolver->work[0];
p = esolver->work[1];
Ax = esolver->work[2];
Ar = esolver->work[3];
Ap = esolver->work[4];
lis_vector_set_all(1.0,x);
lis_vector_nrm2(x,&nrm2);
lis_vector_scale(1/nrm2,x);
lis_matvec(A,x,Ax);
lis_vector_dot(x,Ax,&evalue);
lis_vector_axpyz(-evalue,x,Ax,r);
lis_vector_scale(-1.0,r);
lis_vector_copy(r,p);
lis_matvec(A,p,Ap);
iter=0;
while (iter<emaxiter)
{
iter = iter + 1;
lis_vector_dot(r,Ap,&rAp);
lis_vector_dot(r,p,&rp);
lis_vector_dot(Ap,Ap,&ApAp);
lis_vector_dot(p,Ap,&pAp);
lis_vector_dot(p,p,&pp);
alpha = (rAp - evalue * rp) / (ApAp - evalue * (2.0 * pAp - evalue * pp));
lis_vector_axpy(alpha,p,x);
lis_matvec(A,x,Ax);
lis_vector_dot(x,Ax,&evalue);
lis_vector_nrm2(x, &nrm2);
evalue = evalue / (nrm2 * nrm2);
lis_vector_axpyz(-evalue,x,Ax,r);
lis_vector_scale(-1.0,r);
lis_matvec(A,r,Ar);
lis_vector_dot(Ar,Ap,&ArAp);
lis_vector_dot(p,Ar,&pAr);
lis_vector_dot(r,Ap,&rAp);
lis_vector_dot(r,p,&rp);
beta = - (ArAp - evalue * ((pAr + rAp) - evalue * rp))/ (ApAp - evalue * (2.0 * pAp - evalue * pp));
lis_vector_xpay(r,beta,p);
lis_vector_nrm2(r,&nrm2);
resid = fabs(nrm2 / (evalue));
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->residual[iter] = resid;
if( output & LIS_EPRINT_OUT && A->my_rank==0 ) printf("iter: %5d residual = %e\n", iter, resid);
}
if (resid<tol) break;
}
esolver->iter = iter;
esolver->resid = resid;
esolver->evalue[0] = evalue;
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
if (resid<tol)
{
esolver->retcode = LIS_SUCCESS;
return LIS_SUCCESS;
}
else
{
esolver->retcode = LIS_MAXITER;
return LIS_MAXITER;
}
}
LIS_INT lis_ecg(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x;
LIS_SCALAR evalue;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,iter3,nsolver,i,j,output;
LIS_INT nprocs,my_rank;
LIS_REAL nrm2,resid,resid3;
LIS_SCALAR lshift;
LIS_VECTOR b,D,r,w,p,Aw,Ax,Ap,ones,Ds;
LIS_SCALAR *SA, *SB, *SW, *v3, *SAv3, *SBv3, *z3, *q3, *SBz3, evalue3, ievalue3;
LIS_SOLVER solver;
LIS_PRECON precon;
LIS_MATRIX A0;
LIS_VECTOR x0,z,q;
double times,itimes,ptimes,p_c_times,p_i_times;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
A = esolver->A;
x = esolver->x;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
output = esolver->options[LIS_EOPTIONS_OUTPUT];
lshift = esolver->lshift;
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
SA = (LIS_SCALAR *)lis_malloc(3*3*sizeof(LIS_SCALAR), "lis_ecg::SA");
SB = (LIS_SCALAR *)lis_malloc(3*3*sizeof(LIS_SCALAR), "lis_ecg::SB");
SW = (LIS_SCALAR *)lis_malloc(3*3*sizeof(LIS_SCALAR), "lis_ecg::SW");
v3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::v3");
SAv3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::SAv3");
SBv3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::SBv3");
SBz3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::SBz3");
z3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::z3");
q3 = (LIS_SCALAR *)lis_malloc(3*sizeof(LIS_SCALAR), "lis_ecg::q3");
b = esolver->work[0];
D = esolver->work[1];
Ds = esolver->work[2];
r = esolver->work[3];
w = esolver->work[4];
p = esolver->work[5];
Aw = esolver->work[6];
Ax = esolver->work[7];
Ap = esolver->work[8];
lis_vector_set_all(1.0,b);
lis_vector_nrm2(b, &nrm2);
lis_vector_scale(1/nrm2, b);
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p ilu",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
lis_solve(A, b, x, solver);
lis_vector_copy(b,Ax);
lis_vector_nrm2(x, &nrm2);
lis_vector_set_all(0.0,p);
lis_vector_set_all(0.0,Ap);
lis_precon_create(solver, &precon);
solver->precon = precon;
iter=0;
while (iter<emaxiter)
{
iter = iter + 1;
lis_vector_dot(x,Ax,&evalue);
lis_vector_axpyz(-(evalue),x,Ax,r);
lis_vector_nrm2(r, &nrm2);
resid = fabs(nrm2/(evalue));
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->residual[iter] = resid;
if( output & LIS_EPRINT_OUT && A->my_rank==0 ) printf("iter: %5d residual = %e\n", iter, resid);
}
if (resid<tol) break;
lis_psolve(solver, x, w);
lis_vector_copy(x,Aw);
lis_vector_nrm2(w, &nrm2);
lis_vector_dot(w,Aw,&SA[0]);
lis_vector_dot(x,Aw,&SA[3]);
lis_vector_dot(p,Aw,&SA[6]);
SA[1] = SA[3];
lis_vector_dot(x,Ax,&SA[4]);
lis_vector_dot(p,Ax,&SA[7]);
SA[2] = SA[6];
SA[5] = SA[7];
lis_vector_dot(p,Ap,&SA[8]);
lis_vector_dot(w,w,&SB[0]);
lis_vector_dot(x,w,&SB[3]);
lis_vector_dot(p,w,&SB[6]);
SB[1] = SB[3];
lis_vector_dot(x,x,&SB[4]);
lis_vector_dot(p,x,&SB[7]);
SB[2] = SB[6];
SB[5] = SB[7];
lis_vector_dot(p,p,&SB[8]);
lis_array_set_all(3, 1.0, v3);
iter3=0;
while (iter3<emaxiter)
{
iter3 = iter3 + 1;
lis_array_nrm2(3, v3, &nrm2);
lis_array_scale(3, 1/nrm2, v3);
lis_array_matvec(3, SB, v3, SBv3, LIS_INS_VALUE);
lis_array_invvec(3, SA, SBv3, z3);
lis_array_dot2(3, SBv3, z3, &ievalue3);
if (ievalue3==0)
{
printf("ievalue3 is zero\n");
lis_precon_destroy(precon);
lis_solver_destroy(solver);
esolver->iter = iter;
esolver->resid = resid;
esolver->evalue[0] = evalue;
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_free(SA);
lis_free(SB);
lis_free(SW);
lis_free(v3);
lis_free(SAv3);
lis_free(SBv3);
lis_free(SBz3);
lis_free(z3);
lis_free(q3);
return LIS_BREAKDOWN;
}
lis_array_axpyz(3, -ievalue3, SBv3, z3, q3);
lis_array_nrm2(3, q3, &resid3);
resid3 = fabs(resid3 / ievalue3);
if (resid3<1e-12) break;
lis_array_copy(3,z3,v3);
}
evalue3 = 1 / ievalue3;
lis_vector_scale(v3[0],w);
lis_vector_axpy(v3[2],p,w);
lis_vector_xpay(w,v3[1],x);
lis_vector_copy(w,p);
lis_vector_scale(v3[0],Aw);
lis_vector_axpy(v3[2],Ap,Aw);
lis_vector_xpay(Aw,v3[1],Ax);
lis_vector_copy(Aw,Ap);
lis_vector_nrm2(x,&nrm2);
lis_vector_scale(1/nrm2,x);
lis_vector_scale(1/nrm2,Ax);
lis_vector_nrm2(p,&nrm2);
lis_vector_scale(1/nrm2,p);
lis_vector_scale(1/nrm2,Ap);
lis_solver_get_timeex(solver,×,&itimes,&ptimes,&p_c_times,&p_i_times);
esolver->ptimes += solver->ptimes;
esolver->itimes += solver->itimes;
esolver->p_c_times += solver->p_c_times;
esolver->p_i_times += solver->p_i_times;
}
lis_precon_destroy(precon);
lis_solver_destroy(solver);
esolver->iter = iter;
esolver->resid = resid;
esolver->evalue[0] = evalue;
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_free(SA);
lis_free(SB);
lis_free(SW);
lis_free(v3);
lis_free(SAv3);
lis_free(SBv3);
lis_free(SBz3);
lis_free(z3);
lis_free(q3);
if (resid<tol)
{
esolver->retcode = LIS_SUCCESS;
return LIS_SUCCESS;
}
else
{
esolver->retcode = LIS_MAXITER;
return LIS_MAXITER;
}
}
LIS_INT lis_epi(LIS_ESOLVER esolver)
{
LIS_Comm comm;
LIS_MATRIX A;
LIS_VECTOR v,y,q;
LIS_SCALAR theta;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,output;
LIS_SCALAR oshift,ishift;
LIS_REAL nrm2,resid;
LIS_DEBUG_FUNC_IN;
comm = LIS_COMM_WORLD;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
output = esolver->options[LIS_EOPTIONS_OUTPUT];
#ifdef _COMPLEX
oshift = esolver->params[LIS_EPARAMS_SHIFT - LIS_EOPTIONS_LEN] + esolver->params[LIS_EPARAMS_SHIFT_IM - LIS_EOPTIONS_LEN] * _Complex_I;
#else
oshift = esolver->params[LIS_EPARAMS_SHIFT - LIS_EOPTIONS_LEN];
#endif
A = esolver->A;
v = esolver->x;
if (esolver->options[LIS_EOPTIONS_INITGUESS_ONES] )
{
lis_vector_set_all(1.0,v);
}
y = esolver->work[0];
q = esolver->work[1];
if ( esolver->ishift != 0.0 ) oshift = ishift;
if ( oshift != 0.0 ) lis_matrix_shift_diagonal(A, oshift);
if( output )
{
#ifdef _COMPLEX
lis_printf(comm,"shift : (%e, %e)\n", (double)creal(oshift), (double)cimag(oshift));
#else
lis_printf(comm,"shift : %e\n", (double)oshift);
#endif
}
iter=0;
while (iter<emaxiter)
{
iter = iter+1;
/* v = v / ||v||_2 */
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
/* y = A * v */
lis_matvec(A,v,y);
/* theta = <v,y> */
lis_vector_dot(v, y, &theta);
/* resid = ||y - theta * v||_2 / |theta| */
lis_vector_axpyz(-theta, v, y, q);
lis_vector_nrm2(q, &resid);
resid = resid / fabs(theta);
/* v = y */
lis_vector_copy(y, v);
/* convergence check */
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->rhistory[iter] = resid;
if( output & LIS_EPRINT_OUT ) lis_print_rhistory(comm,iter,resid);
}
if( tol >= resid )
{
esolver->retcode = LIS_SUCCESS;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = theta + oshift;
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
if ( oshift != 0.0 ) lis_matrix_shift_diagonal(A, -oshift);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
}
esolver->retcode = LIS_MAXITER;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = theta + oshift;
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
if ( oshift != 0.0 ) lis_matrix_shift_diagonal(A, -oshift);
LIS_DEBUG_FUNC_OUT;
return LIS_MAXITER;
}
LIS_INT lis_esolve(LIS_MATRIX A, LIS_VECTOR x, LIS_SCALAR *evalue0, LIS_ESOLVER esolver)
{
LIS_INT nesolver,niesolver,emaxiter;
LIS_SCALAR *evalue;
LIS_VECTOR *evector;
LIS_SCALAR *resid;
LIS_SCALAR *rhistory;
LIS_INT *iter,*iter2;
LIS_INT err;
LIS_INT output;
LIS_INT ss, mode;
double time;
double gshift;
LIS_INT estorage,eblock;
LIS_MATRIX B;
LIS_INT eprecision;
LIS_VECTOR xx;
LIS_DEBUG_FUNC_IN;
/* begin parameter check */
err = lis_matrix_check(A,LIS_MATRIX_CHECK_ALL);
if( err ) return err;
if( x==NULL )
{
LIS_SETERR(LIS_ERR_ILL_ARG,"vector x is undefined\n");
return LIS_ERR_ILL_ARG;
}
if( A->n!=x->n )
{
return LIS_ERR_ILL_ARG;
}
if( A->gn<=0 )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Size n(=%d) of matrix A is less than 0\n",A->gn);
return LIS_ERR_ILL_ARG;
}
nesolver = esolver->options[LIS_EOPTIONS_ESOLVER];
niesolver = esolver->options[LIS_EOPTIONS_INNER_ESOLVER];
ss = esolver->options[LIS_EOPTIONS_SUBSPACE];
mode = esolver->options[LIS_EOPTIONS_MODE];
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
gshift = esolver->params[LIS_EPARAMS_SHIFT - LIS_EOPTIONS_LEN];
output = esolver->options[LIS_EOPTIONS_OUTPUT];
estorage = esolver->options[LIS_EOPTIONS_STORAGE];
eblock = esolver->options[LIS_EOPTIONS_STORAGE_BLOCK];
eprecision = esolver->options[LIS_EOPTIONS_PRECISION];
esolver->eprecision = eprecision;
if( nesolver < 1 || nesolver > LIS_ESOLVER_LEN )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_ESOLVER is %d (Set between 1 to %d)\n",nesolver, LIS_ESOLVER_LEN);
return LIS_ERR_ILL_ARG;
}
if( niesolver < 1 || niesolver > 7 )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_INNER_ESOLVER is %d (Set between 1 to 7)\n", niesolver);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_SI && niesolver > 4 )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_INNER_ESOLVER is %d (Set between 1 to 4 for Subspace)\n", niesolver);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_LI && niesolver == LIS_ESOLVER_PI )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_INNER_ESOLVER is %d (Set between 2 to 7 for Lanczos)\n", niesolver);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_AI && (( niesolver == LIS_ESOLVER_PI ) || ( niesolver == LIS_ESOLVER_CG) || ( niesolver == LIS_ESOLVER_JD)) )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_INNER_ESOLVER is %d (Set between 2 to 4 or 6 for Arnoldi)\n", niesolver);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_SI && ss > A->gn )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_SUBSPACE is %d (Set less than or equal to matrix size %d for Subspace)\n", ss, A->gn);
return LIS_ERR_ILL_ARG;
}
if (( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_LI || esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_AI ) && ss > A->gn )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_SUBSPACE is %d (Set less than or equal to matrix size %d for Lanczos and Arnoldi)\n", ss, A->gn);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_SI && mode >= ss )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_MODE is %d (Set less than subspace size %d for Subspace)\n", mode, ss);
return LIS_ERR_ILL_ARG;
}
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == ( LIS_ESOLVER_LI || LIS_ESOLVER_AI ) && mode >= ss )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_MODE is %d (Set less than subspace size %d for Lanczos or Arnoldi)\n", mode, ss);
return LIS_ERR_ILL_ARG;
}
#ifdef USE_QUAD_PRECISION
if( eprecision==LIS_PRECISION_QUAD && lis_esolver_execute_quad[nesolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Quad precision eigensolver %s is not implemented\n",lis_esolvername[nesolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
else if( eprecision==LIS_PRECISION_SWITCH && lis_esolver_execute_switch[nesolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Switch esolver %s is not implemented\n",lis_esolvername[nesolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
if( esolver->options[LIS_EOPTIONS_SWITCH_MAXITER]==-1 )
{
esolver->options[LIS_EOPTIONS_SWITCH_MAXITER] = emaxiter;
}
#endif
/* create eigenvalue array */
if( esolver->evalue ) lis_free(esolver->evalue);
evalue = (LIS_SCALAR *)lis_malloc((ss+2)*sizeof(LIS_SCALAR),"lis_esolve::evalue");
if( evalue==NULL )
{
LIS_SETERR_MEM((ss+2)*sizeof(LIS_SCALAR));
esolver->retcode = err;
return err;
}
evalue[0] = 1.0;
evalue[ss-1] = 1.0;
/* create residual norm array */
if( esolver->resid ) lis_free(esolver->resid);
resid = (LIS_SCALAR *)lis_malloc((ss+2)*sizeof(LIS_SCALAR),"lis_esolve::resid");
if( resid==NULL )
{
LIS_SETERR_MEM((ss+2)*sizeof(LIS_SCALAR));
esolver->retcode = err;
return err;
}
/* create number of iterations array */
if( esolver->iter ) lis_free(esolver->iter);
iter = (LIS_INT *)lis_malloc((ss+2)*sizeof(LIS_SCALAR),"lis_esolve::iter");
if( iter==NULL )
{
LIS_SETERR_MEM((ss+2)*sizeof(LIS_SCALAR));
esolver->retcode = err;
return err;
}
/* create quad precision number of iterations array */
if( esolver->iter2 ) lis_free(esolver->iter2);
iter2 = (LIS_INT *)lis_malloc((ss+2)*sizeof(LIS_SCALAR),"lis_esolve::iter2");
if( iter2==NULL )
{
LIS_SETERR_MEM((ss+2)*sizeof(LIS_SCALAR));
esolver->retcode = err;
return err;
}
/* create initial vector */
#ifndef USE_QUAD_PRECISION
err = lis_vector_duplicate(A,&xx);
#else
if( eprecision==LIS_PRECISION_DOUBLE )
{
err = lis_vector_duplicate(A,&xx);
}
else
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,A,&xx);
}
#endif
if( err )
{
esolver->retcode = err;
return err;
}
if( esolver->options[LIS_EOPTIONS_INITGUESS_ONES] )
{
if( output ) lis_printf(A->comm,"initial vector x : 1\n");
#ifndef USE_QUAD_PRECISION
lis_vector_set_all(1.0,xx);
#else
if( eprecision==LIS_PRECISION_DOUBLE )
{
lis_vector_set_all(1.0,xx);
}
else
{
lis_vector_set_allex_nm(1.0,xx);
}
#endif
}
else
{
if( output ) lis_printf(A->comm,"initial vector x : user defined\n");
#ifndef USE_QUAD_PRECISION
lis_vector_copy(x,xx);
#else
if( eprecision==LIS_PRECISION_DOUBLE )
{
lis_vector_copy(x,xx);
}
else
{
lis_vector_copyex_nm(x,xx);
}
#endif
}
/* global shift */
if ( output ) if( A->my_rank==0 ) printf("shift : %e\n", gshift);
/* create eigenvector array */
if( esolver->evector ) lis_free(esolver->evector);
evector = (LIS_VECTOR *)lis_malloc((ss+2)*sizeof(LIS_VECTOR),"lis_esolve::evector");
if( evector==NULL )
{
LIS_SETERR_MEM((ss+2)*sizeof(LIS_VECTOR));
esolver->retcode = err;
return err;
}
/* create residual history array */
if( esolver->rhistory ) lis_free(esolver->rhistory);
rhistory = (LIS_SCALAR *)lis_malloc((emaxiter+2)*sizeof(LIS_SCALAR),"lis_esolve::rhistory");
if( rhistory==NULL )
{
LIS_SETERR_MEM((emaxiter+2)*sizeof(LIS_SCALAR));
lis_vector_destroy(xx);
esolver->retcode = err;
return err;
}
/* convert matrix */
if( estorage>0 && A->matrix_type!=estorage )
{
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
lis_matrix_set_blocksize(B,eblock,eblock,NULL,NULL);
lis_matrix_set_type(B,estorage);
err = lis_matrix_convert(A,B);
if( err ) return err;
lis_matrix_storage_destroy(A);
lis_matrix_DLU_destroy(A);
lis_matrix_diag_destroy(A->WD);
if( A->l2g_map ) lis_free( A->l2g_map );
if( A->commtable ) lis_commtable_destroy( A->commtable );
if( A->ranges ) lis_free( A->ranges );
err = lis_matrix_copy_struct(B,A);
if( err ) return err;
lis_free(B);
}
esolver->A = A;
esolver->evalue = evalue;
esolver->x = x;
esolver->evector = evector;
rhistory[0] = 1.0;
esolver->rhistory = rhistory;
esolver->resid = resid;
esolver->iter = iter;
esolver->iter2 = iter2;
if( A->my_rank==0 )
{
#ifdef _LONG__DOUBLE
if ( output ) printf("precision : long double\n");
#else
if ( output ) printf("precision : %s\n", lis_eprecisionname[eprecision]);
#endif
#ifdef _LONG__LONG
if ( output ) printf("eigensolver : %s\n", lis_esolvername[nesolver]);
#else
if ( output ) printf("eigensolver : %s\n", lis_esolvername[nesolver]);
#endif
}
if( A->my_rank==0 )
{
#ifdef _LONG__DOUBLE
if ( output ) printf("convergence condition : ||lx-Ax||_2 <= %6.1Le * ||lx||_2\n", esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN]);
#else
if ( output ) printf("convergence condition : ||lx-Ax||_2 <= %6.1e * ||lx||_2\n", esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN]);
#endif
}
if( A->my_rank==0 )
{
if( A->matrix_type==LIS_MATRIX_BSR || A->matrix_type==LIS_MATRIX_BSC )
{
#ifdef _LONG__LONG
if ( output ) printf("matrix storage format : %s(%lld x %lld)\n", lis_estoragename[A->matrix_type-1],eblock,eblock);
#else
if ( output ) printf("matrix storage format : %s(%d x %d)\n", lis_estoragename[A->matrix_type-1],eblock,eblock);
#endif
}
else
{
if ( output ) printf("matrix storage format : %s\n", lis_estoragename[A->matrix_type-1]);
}
}
time = lis_wtime();
esolver->ptime = 0;
esolver->itime = 0;
esolver->p_c_time = 0;
esolver->p_i_time = 0;
if (gshift != 0.0) lis_matrix_shift_diagonal(A, gshift);
/* create work vector */
err = lis_esolver_malloc_work[nesolver](esolver);
if( err )
{
lis_vector_destroy(xx);
esolver->retcode = err;
return err;
}
esolver->x = xx;
esolver->xx = x;
/* execute esolver */
#ifndef USE_QUAD_PRECISION
err = lis_esolver_execute[nesolver](esolver);
#else
if( eprecision==LIS_PRECISION_DOUBLE )
{
err = lis_esolver_execute[nesolver](esolver);
}
else if( eprecision==LIS_PRECISION_QUAD )
{
err = lis_esolver_execute_quad[nesolver](esolver);
}
else if( eprecision==LIS_PRECISION_SWITCH )
{
err = lis_esolver_execute_switch[nesolver](esolver);
}
#endif
esolver->retcode = err;
*evalue0 = esolver->evalue[0];
lis_vector_copy(esolver->x, x);
esolver->time = lis_wtime() - time;
lis_matrix_shift_diagonal(A, -gshift);
if( A->my_rank==0 )
{
if( err )
{
#ifdef _LONG__LONG
if ( output ) printf("eigensolver status : %s(code=%lld)\n\n",lis_ereturncode[err],err);
#else
if ( output ) printf("eigensolver status : %s(code=%d)\n\n",lis_ereturncode[err],err);
#endif
}
else
{
if ( output ) printf("eigensolver status : normal end\n\n");
}
}
if( eprecision==LIS_PRECISION_DOUBLE )
{
esolver->iter2[mode] = esolver->iter[mode];
}
else if( eprecision==LIS_PRECISION_QUAD )
{
esolver->iter2[mode] = 0;
}
lis_vector_destroy(xx);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_eii_quad(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x;
LIS_SCALAR evalue, ievalue;
LIS_SCALAR lshift;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,iter2,output;
LIS_REAL nrm2,resid;
LIS_QUAD_PTR qdot_xz;
LIS_VECTOR z,q;
LIS_SOLVER solver;
double time,itime,ptime,p_c_time,p_i_time;
LIS_INT err;
LIS_PRECON precon;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
LIS_DEBUG_FUNC_IN;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
lshift = esolver->lshift;
output = esolver->options[LIS_EOPTIONS_OUTPUT];
A = esolver->A;
x = esolver->x;
if (esolver->options[LIS_EOPTIONS_INITGUESS_ONES] )
{
lis_vector_set_all(1.0,x);
}
evalue = 1.0;
z = esolver->work[0];
q = esolver->work[1];
LIS_QUAD_SCALAR_MALLOC(qdot_xz,0,1);
iter=0;
ievalue = 1/(evalue);
#ifdef _LONG__DOUBLE
if( output & (A->my_rank==0) ) printf("local shift : %Le\n", lshift);
#else
if( output & (A->my_rank==0) ) printf("local shift : %e\n", lshift);
#endif
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p none -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_solver_get_solvername(nsol, solvername);
lis_solver_get_preconname(precon_type, preconname);
if( output & (A->my_rank==0) ) printf("linear solver : %s\n", solvername);
if( output & (A->my_rank==0) ) printf("preconditioner : %s\n", preconname);
/* create preconditioner */
solver->A = A;
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
while (iter<emaxiter)
{
iter = iter+1;
/* x = x / ||x||_2 */
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
/* z = (A - lshift I)^-1 * x */
lis_solve_kernel(A, x, z, solver, precon);
lis_solver_get_iter(solver,&iter2);
/* 1/evalue = <x,z> */
lis_vector_dotex_mmm(x, z, &qdot_xz);
lis_quad_minus((LIS_QUAD *)qdot_xz.hi);
lis_vector_axpyzex_mmmm(qdot_xz,x,z,q);
lis_quad_minus((LIS_QUAD *)qdot_xz.hi);
ievalue = qdot_xz.hi[0];
/* resid = ||z - 1/evalue * x||_2 / |1/evalue| */
lis_vector_nrm2(q, &resid);
resid = fabs(resid/ievalue);
/* x = z */
lis_vector_copy(z,x);
/* convergence check */
lis_solver_get_timeex(solver,&time,&itime,&ptime,&p_c_time,&p_i_time);
esolver->ptime += solver->ptime;
esolver->itime += solver->itime;
esolver->p_c_time += solver->p_c_time;
esolver->p_i_time += solver->p_i_time;
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->rhistory[iter] = resid;
if( output & LIS_EPRINT_OUT && A->my_rank==0 ) lis_print_rhistory(iter,resid);
}
if( tol >= resid )
{
esolver->retcode = LIS_SUCCESS;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = 1/ievalue;
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_precon_destroy(precon);
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
}
lis_precon_destroy(precon);
esolver->retcode = LIS_MAXITER;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = 1/ievalue;
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
if (lshift != 0)
{
lis_matrix_shift_diagonal(A, -lshift);
}
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_MAXITER;
}
