Date: 2016-03-29T14:58:09+00:00

Actual source code: jd.c
slepc-3.6.3 2016-03-29
Report Typos and Errors

      1: /*

      3:    SLEPc eigensolver: "jd"

      5:    Method: Jacobi-Davidson

      7:    Algorithm:

      9:        Jacobi-Davidson with various subspace extraction and
     10:        restart techniques.

     12:    References:

     14:        [1] G.L.G. Sleijpen and H.A. van der Vorst, "A Jacobi-Davidson
     15:            iteration method for linear eigenvalue problems", SIAM J.
     16:            Matrix Anal. Appl. 17(2):401-425, 1996.

     18:        [2] E. Romero and J.E. Roman, "A parallel implementation of
     19:            Davidson methods for large-scale eigenvalue problems in
     20:            SLEPc", ACM Trans. Math. Software 40(2), Article 13, 2014.

     22:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     23:    SLEPc - Scalable Library for Eigenvalue Problem Computations
     24:    Copyright (c) 2002-2015, Universitat Politecnica de Valencia, Spain

     26:    This file is part of SLEPc.

     28:    SLEPc is free software: you can redistribute it and/or modify it under  the
     29:    terms of version 3 of the GNU Lesser General Public License as published by
     30:    the Free Software Foundation.

     32:    SLEPc  is  distributed in the hope that it will be useful, but WITHOUT  ANY
     33:    WARRANTY;  without even the implied warranty of MERCHANTABILITY or  FITNESS
     34:    FOR  A  PARTICULAR PURPOSE. See the GNU Lesser General Public  License  for
     35:    more details.

     37:    You  should have received a copy of the GNU Lesser General  Public  License
     38:    along with SLEPc. If not, see <http://www.gnu.org/licenses/>.
     39:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     40: */

     42: #include <slepc/private/epsimpl.h>                /*I "slepceps.h" I*/
     43: #include <../src/eps/impls/davidson/davidson.h>

     47: PetscErrorCode EPSSetFromOptions_JD(PetscOptions *PetscOptionsObject,EPS eps)
     48: {
     50:   PetscBool      flg,op;
     51:   PetscInt       opi,opi0;
     52:   PetscReal      opf;
     53:   KSP            ksp;
     54:   PetscBool      orth;
     55:   const char     *orth_list[2] = {"I","B"};

     58:   PetscOptionsHead(PetscOptionsObject,"EPS Jacobi-Davidson (JD) Options");

     60:   EPSJDGetKrylovStart(eps,&op);
     61:   PetscOptionsBool("-eps_jd_krylov_start","Start the searching subspace with a krylov basis","EPSJDSetKrylovStart",op,&op,&flg);
     62:   if (flg) { EPSJDSetKrylovStart(eps,op); }

     64:   EPSJDGetBlockSize(eps,&opi);
     65:   PetscOptionsInt("-eps_jd_blocksize","Number vectors add to the searching subspace","EPSJDSetBlockSize",opi,&opi,&flg);
     66:   if (flg) { EPSJDSetBlockSize(eps,opi); }

     68:   EPSJDGetRestart(eps,&opi,&opi0);
     69:   PetscOptionsInt("-eps_jd_minv","Set the size of the searching subspace after restarting","EPSJDSetRestart",opi,&opi,&flg);
     70:   if (flg) { EPSJDSetRestart(eps,opi,opi0); }

     72:   PetscOptionsInt("-eps_jd_plusk","Set the number of saved eigenvectors from the previous iteration when restarting","EPSJDSetRestart",opi0,&opi0,&flg);
     73:   if (flg) { EPSJDSetRestart(eps,opi,opi0); }

     75:   EPSJDGetInitialSize(eps,&opi);
     76:   PetscOptionsInt("-eps_jd_initial_size","Set the initial size of the searching subspace","EPSJDSetInitialSize",opi,&opi,&flg);
     77:   if (flg) { EPSJDSetInitialSize(eps,opi); }

     79:   EPSJDGetFix(eps,&opf);
     80:   PetscOptionsReal("-eps_jd_fix","Set the tolerance for changing the target in the correction equation","EPSJDSetFix",opf,&opf,&flg);
     81:   if (flg) { EPSJDSetFix(eps,opf); }

     83:   EPSJDGetBOrth(eps,&orth);
     84:   PetscOptionsEList("-eps_jd_borth","orthogonalization used in the search subspace","EPSJDSetBOrth",orth_list,2,orth_list[orth?1:0],&opi,&flg);
     85:   if (flg) { EPSJDSetBOrth(eps,opi==1?PETSC_TRUE:PETSC_FALSE); }

     87:   EPSJDGetConstCorrectionTol(eps,&op);
     88:   PetscOptionsBool("-eps_jd_const_correction_tol","Disable the dynamic stopping criterion when solving the correction equation","EPSJDSetConstCorrectionTol",op,&op,&flg);
     89:   if (flg) { EPSJDSetConstCorrectionTol(eps,op); }

     91:   EPSJDGetWindowSizes(eps,&opi,&opi0);
     92:   PetscOptionsInt("-eps_jd_pwindow","(Experimental!) Set the number of converged vectors in the projector","EPSJDSetWindowSizes",opi,&opi,&flg);
     93:   if (flg) { EPSJDSetWindowSizes(eps,opi,opi0); }

     95:   PetscOptionsInt("-eps_jd_qwindow","(Experimental!) Set the number of converged vectors in the projected problem","EPSJDSetWindowSizes",opi0,&opi0,&flg);
     96:   if (flg) { EPSJDSetWindowSizes(eps,opi,opi0); }

     98:   /* Set STPrecond as the default ST */
     99:   if (!((PetscObject)eps->st)->type_name) {
    100:     STSetType(eps->st,STPRECOND);
    101:   }
    102:   STPrecondSetKSPHasMat(eps->st,PETSC_FALSE);

    104:   /* Set the default options of the KSP */
    105:   STGetKSP(eps->st,&ksp);
    106:   if (!((PetscObject)ksp)->type_name) {
    107:     KSPSetType(ksp,KSPBCGSL);
    108:     KSPSetTolerances(ksp,1e-4,PETSC_DEFAULT,PETSC_DEFAULT,90);
    109:   }
    110:   PetscOptionsTail();
    111:   return(0);
    112: }

    116: PetscErrorCode EPSSetUp_JD(EPS eps)
    117: {
    119:   PetscBool      t;
    120:   KSP            ksp;

    123:   /* Setup common for all davidson solvers */
    124:   EPSSetUp_XD(eps);

    126:   /* Set the default options of the KSP */
    127:   STGetKSP(eps->st,&ksp);
    128:   if (!((PetscObject)ksp)->type_name) {
    129:     KSPSetType(ksp,KSPBCGSL);
    130:     KSPSetTolerances(ksp,1e-4,PETSC_DEFAULT,PETSC_DEFAULT,90);
    131:   }

    133:   /* Check some constraints */
    134:   PetscObjectTypeCompare((PetscObject)ksp,KSPPREONLY,&t);
    135:   if (t) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_SUP,"EPSJD does not work with KSPPREONLY");
    136:   return(0);
    137: }

    141: PetscErrorCode EPSDestroy_JD(EPS eps)
    142: {
    143:   PetscErrorCode  ierr;

    146:   PetscFree(eps->data);
    147:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetKrylovStart_C",NULL);
    148:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetKrylovStart_C",NULL);
    149:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBlockSize_C",NULL);
    150:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBlockSize_C",NULL);
    151:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetRestart_C",NULL);
    152:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetRestart_C",NULL);
    153:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetInitialSize_C",NULL);
    154:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetInitialSize_C",NULL);
    155:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetFix_C",NULL);
    156:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetFix_C",NULL);
    157:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetConstCorrectionTol_C",NULL);
    158:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetConstCorrectionTol_C",NULL);
    159:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetWindowSizes_C",NULL);
    160:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetWindowSizes_C",NULL);
    161:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBOrth_C",NULL);
    162:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBOrth_C",NULL);
    163:   return(0);
    164: }

    168: /*@
    169:    EPSJDSetKrylovStart - Activates or deactivates starting the searching
    170:    subspace with a Krylov basis.

    172:    Logically Collective on EPS

    174:    Input Parameters:
    175: +  eps - the eigenproblem solver context
    176: -  krylovstart - boolean flag

    178:    Options Database Key:
    179: .  -eps_jd_krylov_start - Activates starting the searching subspace with a
    180:     Krylov basis

    182:    Level: advanced

    184: .seealso: EPSJDGetKrylovStart()
    185: @*/
    186: PetscErrorCode EPSJDSetKrylovStart(EPS eps,PetscBool krylovstart)
    187: {

    193:   PetscTryMethod(eps,"EPSJDSetKrylovStart_C",(EPS,PetscBool),(eps,krylovstart));
    194:   return(0);
    195: }

    199: /*@
    200:    EPSJDGetKrylovStart - Returns a flag indicating if the searching subspace is started with a
    201:    Krylov basis.

    203:    Not Collective

    205:    Input Parameter:
    206: .  eps - the eigenproblem solver context

    208:    Output Parameters:
    209: .  krylovstart - boolean flag indicating if the searching subspace is started
    210:    with a Krylov basis

    212:    Level: advanced

    214: .seealso: EPSJDGetKrylovStart()
    215: @*/
    216: PetscErrorCode EPSJDGetKrylovStart(EPS eps,PetscBool *krylovstart)
    217: {

    223:   PetscTryMethod(eps,"EPSJDGetKrylovStart_C",(EPS,PetscBool*),(eps,krylovstart));
    224:   return(0);
    225: }

    229: /*@
    230:    EPSJDSetBlockSize - Sets the number of vectors to be added to the searching space
    231:    in every iteration.

    233:    Logically Collective on EPS

    235:    Input Parameters:
    236: +  eps - the eigenproblem solver context
    237: -  blocksize - number of vectors added to the search space in every iteration

    239:    Options Database Key:
    240: .  -eps_jd_blocksize - number of vectors added to the searching space every iteration

    242:    Level: advanced

    244: .seealso: EPSJDSetKrylovStart()
    245: @*/
    246: PetscErrorCode EPSJDSetBlockSize(EPS eps,PetscInt blocksize)
    247: {

    253:   PetscTryMethod(eps,"EPSJDSetBlockSize_C",(EPS,PetscInt),(eps,blocksize));
    254:   return(0);
    255: }

    259: /*@
    260:    EPSJDGetBlockSize - Returns the number of vectors to be added to the searching space
    261:    in every iteration.

    263:    Not Collective

    265:    Input Parameter:
    266: .  eps - the eigenproblem solver context

    268:    Output Parameter:
    269: .  blocksize - number of vectors added to the search space in every iteration

    271:    Level: advanced

    273: .seealso: EPSJDSetBlockSize()
    274: @*/
    275: PetscErrorCode EPSJDGetBlockSize(EPS eps,PetscInt *blocksize)
    276: {

    282:   PetscTryMethod(eps,"EPSJDGetBlockSize_C",(EPS,PetscInt*),(eps,blocksize));
    283:   return(0);
    284: }

    288: /*@
    289:    EPSJDGetRestart - Gets the number of vectors of the searching space after
    290:    restarting and the number of vectors saved from the previous iteration.

    292:    Not Collective

    294:    Input Parameter:
    295: .  eps - the eigenproblem solver context

    297:    Output Parameter:
    298: +  minv - number of vectors of the searching subspace after restarting
    299: -  plusk - number of vectors saved from the previous iteration

    301:    Level: advanced

    303: .seealso: EPSJDSetRestart()
    304: @*/
    305: PetscErrorCode EPSJDGetRestart(EPS eps,PetscInt *minv,PetscInt *plusk)
    306: {

    311:   PetscTryMethod(eps,"EPSJDGetRestart_C",(EPS,PetscInt*,PetscInt*),(eps,minv,plusk));
    312:   return(0);
    313: }

    317: /*@
    318:    EPSJDSetRestart - Sets the number of vectors of the searching space after
    319:    restarting and the number of vectors saved from the previous iteration.

    321:    Logically Collective on EPS

    323:    Input Parameters:
    324: +  eps - the eigenproblem solver context
    325: .  minv - number of vectors of the searching subspace after restarting
    326: -  plusk - number of vectors saved from the previous iteration

    328:    Options Database Keys:
    329: +  -eps_jd_minv - number of vectors of the searching subspace after restarting
    330: -  -eps_jd_plusk - number of vectors saved from the previous iteration

    332:    Level: advanced

    334: .seealso: EPSJDGetRestart()
    335: @*/
    336: PetscErrorCode EPSJDSetRestart(EPS eps,PetscInt minv,PetscInt plusk)
    337: {

    344:   PetscTryMethod(eps,"EPSJDSetRestart_C",(EPS,PetscInt,PetscInt),(eps,minv,plusk));
    345:   return(0);
    346: }

    350: /*@
    351:    EPSJDGetInitialSize - Returns the initial size of the searching space.

    353:    Not Collective

    355:    Input Parameter:
    356: .  eps - the eigenproblem solver context

    358:    Output Parameter:
    359: .  initialsize - number of vectors of the initial searching subspace

    361:    Notes:
    362:    If EPSJDGetKrylovStart() is PETSC_FALSE and the user provides vectors with
    363:    EPSSetInitialSpace(), up to initialsize vectors will be used; and if the
    364:    provided vectors are not enough, the solver completes the subspace with
    365:    random vectors. In the case of EPSJDGetKrylovStart() being PETSC_TRUE, the solver
    366:    gets the first vector provided by the user or, if not available, a random vector,
    367:    and expands the Krylov basis up to initialsize vectors.

    369:    Level: advanced

    371: .seealso: EPSJDSetInitialSize(), EPSJDGetKrylovStart()
    372: @*/
    373: PetscErrorCode EPSJDGetInitialSize(EPS eps,PetscInt *initialsize)
    374: {

    380:   PetscTryMethod(eps,"EPSJDGetInitialSize_C",(EPS,PetscInt*),(eps,initialsize));
    381:   return(0);
    382: }

    386: /*@
    387:    EPSJDSetInitialSize - Sets the initial size of the searching space.

    389:    Logically Collective on EPS

    391:    Input Parameters:
    392: +  eps - the eigenproblem solver context
    393: -  initialsize - number of vectors of the initial searching subspace

    395:    Options Database Key:
    396: .  -eps_jd_initial_size - number of vectors of the initial searching subspace

    398:    Notes:
    399:    If EPSJDGetKrylovStart() is PETSC_FALSE and the user provides vectors with
    400:    EPSSetInitialSpace(), up to initialsize vectors will be used; and if the
    401:    provided vectors are not enough, the solver completes the subspace with
    402:    random vectors. In the case of EPSJDGetKrylovStart() being PETSC_TRUE, the solver
    403:    gets the first vector provided by the user or, if not available, a random vector,
    404:    and expands the Krylov basis up to initialsize vectors.

    406:    Level: advanced

    408: .seealso: EPSJDGetInitialSize(), EPSJDGetKrylovStart()
    409: @*/
    410: PetscErrorCode EPSJDSetInitialSize(EPS eps,PetscInt initialsize)
    411: {

    417:   PetscTryMethod(eps,"EPSJDSetInitialSize_C",(EPS,PetscInt),(eps,initialsize));
    418:   return(0);
    419: }

    423: /*@
    424:    EPSJDGetFix - Returns the threshold for changing the target in the correction
    425:    equation.

    427:    Not Collective

    429:    Input Parameter:
    430: .  eps - the eigenproblem solver context

    432:    Output Parameter:
    433: .  fix - threshold for changing the target

    435:    Note:
    436:    The target in the correction equation is fixed at the first iterations.
    437:    When the norm of the residual vector is lower than the fix value,
    438:    the target is set to the corresponding eigenvalue.

    440:    Level: advanced

    442: .seealso: EPSJDSetFix()
    443: @*/
    444: PetscErrorCode EPSJDGetFix(EPS eps,PetscReal *fix)
    445: {

    451:   PetscTryMethod(eps,"EPSJDGetFix_C",(EPS,PetscReal*),(eps,fix));
    452:   return(0);
    453: }

    457: /*@
    458:    EPSJDSetFix - Sets the threshold for changing the target in the correction
    459:    equation.

    461:    Logically Collective on EPS

    463:    Input Parameters:
    464: +  eps - the eigenproblem solver context
    465: -  fix - threshold for changing the target

    467:    Options Database Key:
    468: .  -eps_jd_fix - the fix value

    470:    Note:
    471:    The target in the correction equation is fixed at the first iterations.
    472:    When the norm of the residual vector is lower than the fix value,
    473:    the target is set to the corresponding eigenvalue.

    475:    Level: advanced

    477: .seealso: EPSJDGetFix()
    478: @*/
    479: PetscErrorCode EPSJDSetFix(EPS eps,PetscReal fix)
    480: {

    486:   PetscTryMethod(eps,"EPSJDSetFix_C",(EPS,PetscReal),(eps,fix));
    487:   return(0);
    488: }

    492: /*@
    493:    EPSJDSetConstCorrectionTol - If true, deactivates the dynamic stopping criterion
    494:    (also called Newton) that sets the KSP relative tolerance
    495:    to 0.5**i, where i is the number of EPS iterations from the last converged value.

    497:    Logically Collective on EPS

    499:    Input Parameters:
    500: +  eps - the eigenproblem solver context
    501: -  constant - if false, the KSP relative tolerance is set to 0.5**i.

    503:    Options Database Key:
    504: .  -eps_jd_const_correction_tol - Deactivates the dynamic stopping criterion.

    506:    Level: advanced

    508: .seealso: EPSJDGetConstCorrectionTol()
    509: @*/
    510: PetscErrorCode EPSJDSetConstCorrectionTol(EPS eps,PetscBool constant)
    511: {

    517:   PetscTryMethod(eps,"EPSJDSetConstCorrectionTol_C",(EPS,PetscBool),(eps,constant));
    518:   return(0);
    519: }

    523: /*@
    524:    EPSJDGetConstCorrectionTol - Returns a flag indicating if the dynamic stopping is being used for
    525:    solving the correction equation. If the flag is false the KSP relative tolerance is set
    526:    to 0.5**i, where i is the number of EPS iterations from the last converged value.

    528:    Not Collective

    530:    Input Parameter:
    531: .  eps - the eigenproblem solver context

    533:    Output Parameters:
    534: .  constant - boolean flag indicating if the dynamic stopping criterion is not being used.

    536:    Level: advanced

    538: .seealso: EPSJDGetConstCorrectionTol()
    539: @*/
    540: PetscErrorCode EPSJDGetConstCorrectionTol(EPS eps,PetscBool *constant)
    541: {

    547:   PetscTryMethod(eps,"EPSJDGetConstCorrectionTol",(EPS,PetscBool*),(eps,constant));
    548:   return(0);
    549: }

    553: /*@
    554:    EPSJDGetWindowSizes - Gets the number of converged vectors in the projected
    555:    problem (or Rayleigh quotient) and in the projector employed in the correction
    556:    equation.

    558:    Not Collective

    560:    Input Parameter:
    561: .  eps - the eigenproblem solver context

    563:    Output Parameter:
    564: +  pwindow - number of converged vectors in the projector
    565: -  qwindow - number of converged vectors in the projected problem

    567:    Level: advanced

    569: .seealso: EPSJDSetWindowSizes()
    570: @*/
    571: PetscErrorCode EPSJDGetWindowSizes(EPS eps,PetscInt *pwindow,PetscInt *qwindow)
    572: {

    577:   PetscTryMethod(eps,"EPSJDGetWindowSizes_C",(EPS,PetscInt*,PetscInt*),(eps,pwindow,qwindow));
    578:   return(0);
    579: }

    583: /*@
    584:    EPSJDSetWindowSizes - Sets the number of converged vectors in the projected
    585:    problem (or Rayleigh quotient) and in the projector employed in the correction
    586:    equation.

    588:    Logically Collective on EPS

    590:    Input Parameters:
    591: +  eps - the eigenproblem solver context
    592: .  pwindow - number of converged vectors in the projector
    593: -  qwindow - number of converged vectors in the projected problem

    595:    Options Database Keys:
    596: +  -eps_jd_pwindow - set the number of converged vectors in the projector
    597: -  -eps_jd_qwindow - set the number of converged vectors in the projected problem

    599:    Level: advanced

    601: .seealso: EPSJDGetWindowSizes()
    602: @*/
    603: PetscErrorCode EPSJDSetWindowSizes(EPS eps,PetscInt pwindow,PetscInt qwindow)
    604: {

    611:   PetscTryMethod(eps,"EPSJDSetWindowSizes_C",(EPS,PetscInt,PetscInt),(eps,pwindow,qwindow));
    612:   return(0);
    613: }

    617: /*@
    618:    EPSJDSetBOrth - Selects the orthogonalization that will be used in the search
    619:    subspace in case of generalized Hermitian problems.

    621:    Logically Collective on EPS

    623:    Input Parameters:
    624: +  eps   - the eigenproblem solver context
    625: -  borth - whether to B-orthogonalize the search subspace

    627:    Options Database Key:
    628: .  -eps_jd_borth - Set the orthogonalization used in the search subspace

    630:    Level: advanced

    632: .seealso: EPSJDGetBOrth()
    633: @*/
    634: PetscErrorCode EPSJDSetBOrth(EPS eps,PetscBool borth)
    635: {

    641:   PetscTryMethod(eps,"EPSJDSetBOrth_C",(EPS,PetscBool),(eps,borth));
    642:   return(0);
    643: }

    647: /*@
    648:    EPSJDGetBOrth - Returns the orthogonalization used in the search
    649:    subspace in case of generalized Hermitian problems.

    651:    Not Collective

    653:    Input Parameter:
    654: .  eps - the eigenproblem solver context

    656:    Output Parameters:
    657: .  borth - whether to B-orthogonalize the search subspace

    659:    Level: advanced

    661: .seealso: EPSJDSetBOrth()
    662: @*/
    663: PetscErrorCode EPSJDGetBOrth(EPS eps,PetscBool *borth)
    664: {

    670:   PetscTryMethod(eps,"EPSJDGetBOrth_C",(EPS,PetscBool*),(eps,borth));
    671:   return(0);
    672: }

    676: PETSC_EXTERN PetscErrorCode EPSCreate_JD(EPS eps)
    677: {

    681:   /* Load the Davidson solver */
    682:   EPSCreate_XD(eps);
    683:   EPSXDSetMethod(eps,DVD_METH_JD);

    685:   /* Overload the JD properties */
    686:   eps->ops->setfromoptions = EPSSetFromOptions_JD;
    687:   eps->ops->setup          = EPSSetUp_JD;
    688:   eps->ops->destroy        = EPSDestroy_JD;

    690:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetKrylovStart_C",EPSXDSetKrylovStart_XD);
    691:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetKrylovStart_C",EPSXDGetKrylovStart_XD);
    692:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBlockSize_C",EPSXDSetBlockSize_XD);
    693:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBlockSize_C",EPSXDGetBlockSize_XD);
    694:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetRestart_C",EPSXDSetRestart_XD);
    695:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetRestart_C",EPSXDGetRestart_XD);
    696:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetInitialSize_C",EPSXDSetInitialSize_XD);
    697:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetInitialSize_C",EPSXDGetInitialSize_XD);
    698:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetFix_C",EPSJDSetFix_JD);
    699:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetFix_C",EPSXDGetFix_XD);
    700:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetConstCorrectionTol_C",EPSJDSetConstCorrectionTol_JD);
    701:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetConstCorrectionTol_C",EPSJDGetConstCorrectionTol_JD);
    702:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetWindowSizes_C",EPSXDSetWindowSizes_XD);
    703:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetWindowSizes_C",EPSXDGetWindowSizes_XD);
    704:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBOrth_C",EPSXDSetBOrth_XD);
    705:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBOrth_C",EPSXDGetBOrth_XD);
    706:   return(0);
    707: }