Actual source code: ex40.c

      1: /*
      2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

      6:    This file is part of SLEPc.
      7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
      8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      9: */

     11: static char help[] = "Checking the definite property in quadratic symmetric eigenproblem.\n\n"
     12:   "The command line options are:\n"
     13:   "  -n <n> ... dimension of the matrices.\n"
     14:   "  -transform... whether to transform to a hyperbolic problem or not.\n"
     15:   "  -nonhyperbolic... to test with a modified (definite) problem that is not hyperbolic.\n\n";

     17: #include <slepcpep.h>

     19: /*
     20:   This example is based on spring.c, for fixed values mu=1,tau=10,kappa=5

     22:   The transformations are based on the method proposed in [Niendorf and Voss, LAA 2010].
     23: */

     25: PetscErrorCode QEPDefiniteTransformGetMatrices(PEP,PetscBool,PetscReal,PetscReal,Mat[3]);
     26: PetscErrorCode QEPDefiniteTransformMap(PetscBool,PetscReal,PetscReal,PetscInt,PetscScalar*,PetscBool);
     27: PetscErrorCode QEPDefiniteCheckError(Mat*,PEP,PetscBool,PetscReal,PetscReal);
     28: PetscErrorCode TransformMatricesMoebius(Mat[3],MatStructure,PetscReal,PetscReal,PetscReal,PetscReal,Mat[3]);

     30: int main(int argc,char **argv)
     31: {
     32:   Mat            M,C,K,*Op,A[3],At[3],B[3]; /* problem matrices */
     33:   PEP            pep;        /* polynomial eigenproblem solver context */
     34:   ST             st;         /* spectral transformation context */
     35:   KSP            ksp;
     36:   PC             pc;
     37:   PEPProblemType type;
     38:   PetscBool      terse,transform=PETSC_FALSE,nohyp=PETSC_FALSE;
     39:   PetscInt       n=100,Istart,Iend,i,def=0,hyp;
     40:   PetscReal      muu=1,tau=10,kappa=5,inta,intb;
     41:   PetscReal      alpha,beta,xi,mu,at[2]={0.0,0.0},c=.857,s;
     42:   PetscScalar    target,targett,ats[2];

     44:   PetscFunctionBeginUser;
     45:   PetscCall(SlepcInitialize(&argc,&argv,NULL,help));

     47:   PetscCall(PetscOptionsGetInt(NULL,NULL,"-n",&n,NULL));
     48:   PetscCall(PetscPrintf(PETSC_COMM_WORLD,"\nPEP example that checks definite property, n=%" PetscInt_FMT "\n\n",n));

     50:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     51:      Compute the matrices that define the eigensystem, (k^2*M+k*C+K)x=0
     52:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

     54:   /* K is a tridiagonal */
     55:   PetscCall(MatCreate(PETSC_COMM_WORLD,&K));
     56:   PetscCall(MatSetSizes(K,PETSC_DECIDE,PETSC_DECIDE,n,n));
     57:   PetscCall(MatSetFromOptions(K));

     59:   PetscCall(MatGetOwnershipRange(K,&Istart,&Iend));
     60:   for (i=Istart;i<Iend;i++) {
     61:     if (i>0) PetscCall(MatSetValue(K,i,i-1,-kappa,INSERT_VALUES));
     62:     PetscCall(MatSetValue(K,i,i,kappa*3.0,INSERT_VALUES));
     63:     if (i<n-1) PetscCall(MatSetValue(K,i,i+1,-kappa,INSERT_VALUES));
     64:   }

     66:   PetscCall(MatAssemblyBegin(K,MAT_FINAL_ASSEMBLY));
     67:   PetscCall(MatAssemblyEnd(K,MAT_FINAL_ASSEMBLY));

     69:   /* C is a tridiagonal */
     70:   PetscCall(MatCreate(PETSC_COMM_WORLD,&C));
     71:   PetscCall(MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,n,n));
     72:   PetscCall(MatSetFromOptions(C));

     74:   PetscCall(MatGetOwnershipRange(C,&Istart,&Iend));
     75:   for (i=Istart;i<Iend;i++) {
     76:     if (i>0) PetscCall(MatSetValue(C,i,i-1,-tau,INSERT_VALUES));
     77:     PetscCall(MatSetValue(C,i,i,tau*3.0,INSERT_VALUES));
     78:     if (i<n-1) PetscCall(MatSetValue(C,i,i+1,-tau,INSERT_VALUES));
     79:   }

     81:   PetscCall(MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY));
     82:   PetscCall(MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY));

     84:   /* M is a diagonal matrix */
     85:   PetscCall(MatCreate(PETSC_COMM_WORLD,&M));
     86:   PetscCall(MatSetSizes(M,PETSC_DECIDE,PETSC_DECIDE,n,n));
     87:   PetscCall(MatSetFromOptions(M));
     88:   PetscCall(MatGetOwnershipRange(M,&Istart,&Iend));
     89:   for (i=Istart;i<Iend;i++) PetscCall(MatSetValue(M,i,i,muu,INSERT_VALUES));
     90:   PetscCall(MatAssemblyBegin(M,MAT_FINAL_ASSEMBLY));
     91:   PetscCall(MatAssemblyEnd(M,MAT_FINAL_ASSEMBLY));

     93:   PetscCall(PetscOptionsGetBool(NULL,NULL,"-nonhyperbolic",&nohyp,NULL));
     94:   A[0] = K; A[1] = C; A[2] = M;
     95:   if (nohyp) {
     96:     s = c*.6;
     97:     PetscCall(TransformMatricesMoebius(A,UNKNOWN_NONZERO_PATTERN,c,s,-s,c,At));
     98:     for (i=0;i<3;i++) PetscCall(MatDestroy(&A[i]));
     99:     Op = At;
    100:   } else Op = A;

    102:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    103:                 Create the eigensolver and solve the problem
    104:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

    106:   /*
    107:      Create eigensolver context
    108:   */
    109:   PetscCall(PEPCreate(PETSC_COMM_WORLD,&pep));
    110:   PetscCall(PEPSetProblemType(pep,PEP_HERMITIAN));
    111:   PetscCall(PEPSetType(pep,PEPSTOAR));
    112:   /*
    113:      Set operators and set problem type
    114:   */
    115:   PetscCall(PEPSetOperators(pep,3,Op));

    117:   /*
    118:      Set shift-and-invert with Cholesky; select MUMPS if available
    119:   */
    120:   PetscCall(PEPGetST(pep,&st));
    121:   PetscCall(STGetKSP(st,&ksp));
    122:   PetscCall(KSPSetType(ksp,KSPPREONLY));
    123:   PetscCall(KSPGetPC(ksp,&pc));
    124:   PetscCall(PCSetType(pc,PCCHOLESKY));

    126:   /*
    127:      Use MUMPS if available.
    128:      Note that in complex scalars we cannot use MUMPS for spectrum slicing,
    129:      because MatGetInertia() is not available in that case.
    130:   */
    131: #if defined(PETSC_HAVE_MUMPS) && !defined(PETSC_USE_COMPLEX)
    132:   PetscCall(PCFactorSetMatSolverType(pc,MATSOLVERMUMPS));
    133:   /*
    134:      Add several MUMPS options (see ex43.c for a better way of setting them in program):
    135:      '-st_mat_mumps_icntl_13 1': turn off ScaLAPACK for matrix inertia
    136:   */
    137:   PetscCall(PetscOptionsInsertString(NULL,"-st_mat_mumps_icntl_13 1 -st_mat_mumps_icntl_24 1 -st_mat_mumps_cntl_3 1e-12"));
    138: #endif

    140:   /*
    141:      Set solver parameters at runtime
    142:   */
    143:   PetscCall(PEPSetFromOptions(pep));

    145:   PetscCall(PetscOptionsGetBool(NULL,NULL,"-transform",&transform,NULL));
    146:   if (transform) {
    147:     /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    148:                     Check if the problem is definite
    149:        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
    150:     PetscCall(PEPCheckDefiniteQEP(pep,&xi,&mu,&def,&hyp));
    151:     switch (def) {
    152:       case 1:
    153:         if (hyp==1) PetscCall(PetscPrintf(PETSC_COMM_WORLD,"Hyperbolic Problem xi=%g\n",(double)xi));
    154:         else PetscCall(PetscPrintf(PETSC_COMM_WORLD,"Definite Problem xi=%g mu=%g\n",(double)xi,(double)mu));
    155:         break;
    156:       case -1:
    157:         PetscCall(PetscPrintf(PETSC_COMM_WORLD,"Not Definite Problem\n"));
    158:         break;
    159:       default:
    160:         PetscCall(PetscPrintf(PETSC_COMM_WORLD,"Cannot determine definiteness\n"));
    161:         break;
    162:     }

    164:     /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    165:       Transform the QEP to have a definite inner product in the linearization
    166:        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
    167:     if (def==1) {
    168:       PetscCall(QEPDefiniteTransformGetMatrices(pep,hyp==1?PETSC_TRUE:PETSC_FALSE,xi,mu,B));
    169:       PetscCall(PEPSetOperators(pep,3,B));
    170:       PetscCall(PEPGetTarget(pep,&target));
    171:       targett = target;
    172:       PetscCall(QEPDefiniteTransformMap(hyp==1?PETSC_TRUE:PETSC_FALSE,xi,mu,1,&targett,PETSC_FALSE));
    173:       PetscCall(PEPSetTarget(pep,targett));
    174:       PetscCall(PEPGetProblemType(pep,&type));
    175:       PetscCall(PEPSetProblemType(pep,PEP_HYPERBOLIC));
    176:       PetscCall(PEPSTOARGetLinearization(pep,&alpha,&beta));
    177:       PetscCall(PEPSTOARSetLinearization(pep,1.0,0.0));
    178:       PetscCall(PEPGetInterval(pep,&inta,&intb));
    179:       if (inta!=intb) {
    180:         ats[0] = inta; ats[1] = intb;
    181:         PetscCall(QEPDefiniteTransformMap(hyp==1?PETSC_TRUE:PETSC_FALSE,xi,mu,2,ats,PETSC_FALSE));
    182:         at[0] = PetscRealPart(ats[0]); at[1] = PetscRealPart(ats[1]);
    183:         if (at[0]<at[1]) PetscCall(PEPSetInterval(pep,at[0],at[1]));
    184:         else PetscCall(PEPSetInterval(pep,PETSC_MIN_REAL,at[1]));
    185:       }
    186:     }
    187:   }

    189:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    190:                       Solve the eigensystem
    191:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
    192:   PetscCall(PEPSolve(pep));

    194:   /* show detailed info unless -terse option is given by user */
    195:   if (def!=1) {
    196:     PetscCall(PetscOptionsHasName(NULL,NULL,"-terse",&terse));
    197:     if (terse) PetscCall(PEPErrorView(pep,PEP_ERROR_BACKWARD,NULL));
    198:     else {
    199:       PetscCall(PetscViewerPushFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_INFO_DETAIL));
    200:       PetscCall(PEPConvergedReasonView(pep,PETSC_VIEWER_STDOUT_WORLD));
    201:       PetscCall(PEPErrorView(pep,PEP_ERROR_RELATIVE,PETSC_VIEWER_STDOUT_WORLD));
    202:       PetscCall(PetscViewerPopFormat(PETSC_VIEWER_STDOUT_WORLD));
    203:     }
    204:   } else {
    205:     /* Map the solution */
    206:     PetscCall(PEPConvergedReasonView(pep,PETSC_VIEWER_STDOUT_WORLD));
    207:     PetscCall(QEPDefiniteCheckError(Op,pep,hyp==1?PETSC_TRUE:PETSC_FALSE,xi,mu));
    208:     for (i=0;i<3;i++) PetscCall(MatDestroy(B+i));
    209:   }
    210:   if (at[0]>at[1]) {
    211:     PetscCall(PEPSetInterval(pep,at[0],PETSC_MAX_REAL));
    212:     PetscCall(PEPSolve(pep));
    213:     PetscCall(PEPConvergedReasonView(pep,PETSC_VIEWER_STDOUT_WORLD));
    214:     /* Map the solution */
    215:     PetscCall(QEPDefiniteCheckError(Op,pep,hyp==1?PETSC_TRUE:PETSC_FALSE,xi,mu));
    216:   }
    217:   if (def==1) {
    218:     PetscCall(PEPSetTarget(pep,target));
    219:     PetscCall(PEPSetProblemType(pep,type));
    220:     PetscCall(PEPSTOARSetLinearization(pep,alpha,beta));
    221:     if (inta!=intb) PetscCall(PEPSetInterval(pep,inta,intb));
    222:   }

    224:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    225:                     Clean up
    226:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
    227:   PetscCall(PEPDestroy(&pep));
    228:   for (i=0;i<3;i++) PetscCall(MatDestroy(Op+i));
    229:   PetscCall(SlepcFinalize());
    230:   return 0;
    231: }

    233: /* ------------------------------------------------------------------- */
    234: /*
    235:   QEPDefiniteTransformMap_Initial - map a scalar value with a certain Moebius transform

    237:                    a theta + b
    238:          lambda = --------------
    239:                    c theta + d

    241:   Input:
    242:     xi,mu: real values such that Q(xi)<0 and Q(mu)>0
    243:     hyperbolic: if true the problem is assumed hyperbolic (mu is not used)
    244:   Input/Output:
    245:     val (array of length n)
    246:     if backtransform=true returns lambda from theta, else returns theta from lambda
    247: */
    248: static PetscErrorCode QEPDefiniteTransformMap_Initial(PetscBool hyperbolic,PetscReal xi,PetscReal mu,PetscInt n,PetscScalar *val,PetscBool backtransform)
    249: {
    250:   PetscInt  i;
    251:   PetscReal a,b,c,d,s;

    253:   PetscFunctionBegin;
    254:   if (hyperbolic) { a = 1.0; b = xi; c =0.0; d = 1.0; }
    255:   else { a = mu; b = mu*xi-1; c = 1.0; d = xi+mu; }
    256:   if (!backtransform) { s = a; a = -d; d = -s; }
    257:   for (i=0;i<n;i++) {
    258:     if (PetscRealPart(val[i]) >= PETSC_MAX_REAL || PetscRealPart(val[i]) <= PETSC_MIN_REAL) val[i] = a/c;
    259:     else if (val[i] == -d/c) val[i] = PETSC_MAX_REAL;
    260:     else val[i] = (a*val[i]+b)/(c*val[i]+d);
    261:   }
    262:   PetscFunctionReturn(PETSC_SUCCESS);
    263: }

    265: /* ------------------------------------------------------------------- */
    266: /*
    267:   QEPDefiniteTransformMap - perform the mapping if the problem is hyperbolic, otherwise
    268:   modify the value of xi in advance
    269: */
    270: PetscErrorCode QEPDefiniteTransformMap(PetscBool hyperbolic,PetscReal xi,PetscReal mu,PetscInt n,PetscScalar *val,PetscBool backtransform)
    271: {
    272:   PetscReal      xit;
    273:   PetscScalar    alpha;

    275:   PetscFunctionBegin;
    276:   xit = xi;
    277:   if (!hyperbolic) {
    278:     alpha = xi;
    279:     PetscCall(QEPDefiniteTransformMap_Initial(PETSC_FALSE,0.0,mu,1,&alpha,PETSC_FALSE));
    280:     xit = PetscRealPart(alpha);
    281:   }
    282:   PetscCall(QEPDefiniteTransformMap_Initial(hyperbolic,xit,mu,n,val,backtransform));
    283:   PetscFunctionReturn(PETSC_SUCCESS);
    284: }

    286: /* ------------------------------------------------------------------- */
    287: /*
    288:   TransformMatricesMoebius - transform the coefficient matrices of a QEP

    290:   Input:
    291:     A: coefficient matrices of the original QEP
    292:     a,b,c,d: parameters of the Moebius transform
    293:     str: structure flag for MatAXPY operations
    294:   Output:
    295:     B: transformed matrices
    296: */
    297: PetscErrorCode TransformMatricesMoebius(Mat A[3],MatStructure str,PetscReal a,PetscReal b,PetscReal c,PetscReal d,Mat B[3])
    298: {
    299:   PetscInt       i,k;
    300:   PetscReal      cf[9];

    302:   PetscFunctionBegin;
    303:   for (i=0;i<3;i++) PetscCall(MatDuplicate(A[2],MAT_COPY_VALUES,&B[i]));
    304:   /* Ct = b*b*A+b*d*B+d*d*C */
    305:   cf[0] = d*d; cf[1] = b*d; cf[2] = b*b;
    306:   /* Bt = 2*a*b*A+(b*c+a*d)*B+2*c*d*C*/
    307:   cf[3] = 2*c*d; cf[4] = b*c+a*d; cf[5] = 2*a*b;
    308:   /* At = a*a*A+a*c*B+c*c*C */
    309:   cf[6] = c*c; cf[7] = a*c; cf[8] = a*a;
    310:   for (k=0;k<3;k++) {
    311:     PetscCall(MatScale(B[k],cf[k*3+2]));
    312:     for (i=0;i<2;i++) PetscCall(MatAXPY(B[k],cf[3*k+i],A[i],str));
    313:   }
    314:   PetscFunctionReturn(PETSC_SUCCESS);
    315: }

    317: /* ------------------------------------------------------------------- */
    318: /*
    319:   QEPDefiniteTransformGetMatrices - given a PEP of degree 2, transform the three
    320:   matrices with TransformMatricesMoebius

    322:   Input:
    323:     pep: polynomial eigenproblem to be transformed, with Q(.) being the quadratic polynomial
    324:     xi,mu: real values such that Q(xi)<0 and Q(mu)>0
    325:     hyperbolic: if true the problem is assumed hyperbolic (mu is not used)
    326:   Output:
    327:     T: coefficient matrices of the transformed polynomial
    328: */
    329: PetscErrorCode QEPDefiniteTransformGetMatrices(PEP pep,PetscBool hyperbolic,PetscReal xi,PetscReal mu,Mat T[3])
    330: {
    331:   MatStructure   str;
    332:   ST             st;
    333:   PetscInt       i;
    334:   PetscReal      a,b,c,d;
    335:   PetscScalar    xit;
    336:   Mat            A[3];

    338:   PetscFunctionBegin;
    339:   for (i=2;i>=0;i--) PetscCall(PEPGetOperators(pep,i,&A[i]));
    340:   if (hyperbolic) { a = 1.0; b = xi; c =0.0; d = 1.0; }
    341:   else {
    342:     xit = xi;
    343:     PetscCall(QEPDefiniteTransformMap_Initial(PETSC_FALSE,0.0,mu,1,&xit,PETSC_FALSE));
    344:     a = mu; b = mu*PetscRealPart(xit)-1.0; c = 1.0; d = PetscRealPart(xit)+mu;
    345:   }
    346:   PetscCall(PEPGetST(pep,&st));
    347:   PetscCall(STGetMatStructure(st,&str));
    348:   PetscCall(TransformMatricesMoebius(A,str,a,b,c,d,T));
    349:   PetscFunctionReturn(PETSC_SUCCESS);
    350: }

    352: /* ------------------------------------------------------------------- */
    353: /*
    354:   Auxiliary function to compute the residual norm of an eigenpair of a QEP defined
    355:   by coefficient matrices A
    356: */
    357: static PetscErrorCode PEPResidualNorm(Mat *A,PetscScalar kr,PetscScalar ki,Vec xr,Vec xi,Vec *z,PetscReal *norm)
    358: {
    359:   PetscInt       i,nmat=3;
    360:   PetscScalar    vals[3];
    361:   Vec            u,w;
    362: #if !defined(PETSC_USE_COMPLEX)
    363:   Vec            ui,wi;
    364:   PetscReal      ni;
    365:   PetscBool      imag;
    366:   PetscScalar    ivals[3];
    367: #endif

    369:   PetscFunctionBegin;
    370:   u = z[0]; w = z[1];
    371:   PetscCall(VecSet(u,0.0));
    372: #if !defined(PETSC_USE_COMPLEX)
    373:   ui = z[2]; wi = z[3];
    374: #endif
    375:   vals[0] = 1.0;
    376:   vals[1] = kr;
    377:   vals[2] = kr*kr-ki*ki;
    378: #if !defined(PETSC_USE_COMPLEX)
    379:   ivals[0] = 0.0;
    380:   ivals[1] = ki;
    381:   ivals[2] = 2.0*kr*ki;
    382:   if (ki == 0 || PetscAbsScalar(ki) < PetscAbsScalar(kr*PETSC_MACHINE_EPSILON))
    383:     imag = PETSC_FALSE;
    384:   else {
    385:     imag = PETSC_TRUE;
    386:     PetscCall(VecSet(ui,0.0));
    387:   }
    388: #endif
    389:   for (i=0;i<nmat;i++) {
    390:     if (vals[i]!=0.0) {
    391:       PetscCall(MatMult(A[i],xr,w));
    392:       PetscCall(VecAXPY(u,vals[i],w));
    393:     }
    394: #if !defined(PETSC_USE_COMPLEX)
    395:     if (imag) {
    396:       if (ivals[i]!=0 || vals[i]!=0) {
    397:         PetscCall(MatMult(A[i],xi,wi));
    398:         if (vals[i]==0) PetscCall(MatMult(A[i],xr,w));
    399:       }
    400:       if (ivals[i]!=0) {
    401:         PetscCall(VecAXPY(u,-ivals[i],wi));
    402:         PetscCall(VecAXPY(ui,ivals[i],w));
    403:       }
    404:       if (vals[i]!=0) PetscCall(VecAXPY(ui,vals[i],wi));
    405:     }
    406: #endif
    407:   }
    408:   PetscCall(VecNorm(u,NORM_2,norm));
    409: #if !defined(PETSC_USE_COMPLEX)
    410:   if (imag) {
    411:     PetscCall(VecNorm(ui,NORM_2,&ni));
    412:     *norm = SlepcAbsEigenvalue(*norm,ni);
    413:   }
    414: #endif
    415:   PetscFunctionReturn(PETSC_SUCCESS);
    416: }

    418: /* ------------------------------------------------------------------- */
    419: /*
    420:   QEPDefiniteCheckError - check and print the residual norm of a transformed PEP

    422:   Input:
    423:     A: coefficient matrices of the original problem
    424:     pep: solver containing the computed solution of the transformed problem
    425:     xi,mu,hyperbolic: parameters used in transformation
    426: */
    427: PetscErrorCode QEPDefiniteCheckError(Mat *A,PEP pep,PetscBool hyperbolic,PetscReal xi,PetscReal mu)
    428: {
    429:   PetscScalar    er,ei;
    430:   PetscReal      re,im,error;
    431:   Vec            vr,vi,w[4];
    432:   PetscInt       i,nconv;
    433:   BV             bv;
    434:   char           ex[30],sep[]=" ---------------------- --------------------\n";

    436:   PetscFunctionBegin;
    437:   PetscCall(PetscSNPrintf(ex,sizeof(ex),"||P(k)x||/||kx||"));
    438:   PetscCall(PetscPrintf(PETSC_COMM_WORLD,"%s            k             %s\n%s",sep,ex,sep));
    439:   PetscCall(PEPGetConverged(pep,&nconv));
    440:   PetscCall(PEPGetBV(pep,&bv));
    441:   PetscCall(BVCreateVec(bv,w));
    442:   PetscCall(VecDuplicate(w[0],&vr));
    443:   PetscCall(VecDuplicate(w[0],&vi));
    444:   for (i=1;i<4;i++) PetscCall(VecDuplicate(w[0],w+i));
    445:   for (i=0;i<nconv;i++) {
    446:     PetscCall(PEPGetEigenpair(pep,i,&er,&ei,vr,vi));
    447:     PetscCall(QEPDefiniteTransformMap(hyperbolic,xi,mu,1,&er,PETSC_TRUE));
    448:     PetscCall(PEPResidualNorm(A,er,0.0,vr,vi,w,&error));
    449:     error /= SlepcAbsEigenvalue(er,0.0);
    450: #if defined(PETSC_USE_COMPLEX)
    451:     re = PetscRealPart(er);
    452:     im = PetscImaginaryPart(ei);
    453: #else
    454:     re = er;
    455:     im = ei;
    456: #endif
    457:     if (im!=0.0) PetscCall(PetscPrintf(PETSC_COMM_WORLD,"  % 9f%+9fi      %12g\n",(double)re,(double)im,(double)error));
    458:     else PetscCall(PetscPrintf(PETSC_COMM_WORLD,"    % 12f           %12g\n",(double)re,(double)error));
    459:   }
    460:   PetscCall(PetscPrintf(PETSC_COMM_WORLD,"%s",sep));
    461:   for (i=0;i<4;i++) PetscCall(VecDestroy(w+i));
    462:   PetscCall(VecDestroy(&vi));
    463:   PetscCall(VecDestroy(&vr));
    464:   PetscFunctionReturn(PETSC_SUCCESS);
    465: }

    467: /*TEST

    469:    testset:
    470:       requires: !single
    471:       args: -pep_nev 3 -nonhyperbolic -pep_target 2
    472:       output_file: output/ex40_1.out
    473:       filter: grep -v "Definite" | sed -e "s/iterations [0-9]\([0-9]*\)/iterations xx/g" | sed -e "s/[0-9]\.[0-9]*e[+-]\([0-9]*\)/removed/g"
    474:       test:
    475:          suffix: 1
    476:          requires: !complex
    477:       test:
    478:          suffix: 1_complex
    479:          requires: complex !mumps
    480:       test:
    481:          suffix: 1_transform
    482:          requires: !complex
    483:          args: -transform
    484:       test:
    485:          suffix: 1_transform_complex
    486:          requires: complex !mumps
    487:          args: -transform

    489: TEST*/