Date: 2024-09-25T09:34:14+00:00

Actual source code: zsvdf.c
slepc-3.21.2 2024-09-25
Report Typos and Errors

      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: #include <petsc/private/fortranimpl.h>
     12: #include <slepcsvd.h>

     14: #if defined(PETSC_HAVE_FORTRAN_CAPS)
     15: #define svddestroy_                       SVDDESTROY
     16: #define svdview_                          SVDVIEW
     17: #define svderrorview_                     SVDERRORVIEW
     18: #define svdconvergedreasonview_           SVDCONVERGEDREASONVIEW
     19: #define svdvaluesview_                    SVDVALUESVIEW
     20: #define svdvectorsview_                   SVDVECTORSVIEW
     21: #define svdsettype_                       SVDSETTYPE
     22: #define svdgettype_                       SVDGETTYPE
     23: #define svdmonitorset_                    SVDMONITORSET
     24: #define svdmonitorall_                    SVDMONITORALL
     25: #define svdmonitorfirst_                  SVDMONITORFIRST
     26: #define svdmonitorconditioning_           SVDMONITORCONDITIONING
     27: #define svdmonitorconverged_              SVDMONITORCONVERGED
     28: #define svdmonitorconvergedcreate_        SVDMONITORCONVERGEDCREATE
     29: #define svdmonitorconvergeddestroy_       SVDMONITORCONVERGEDDESTROY
     30: #define svdsetoptionsprefix_              SVDSETOPTIONSPREFIX
     31: #define svdappendoptionsprefix_           SVDAPPENDOPTIONSPREFIX
     32: #define svdgetoptionsprefix_              SVDGETOPTIONSPREFIX
     33: #define svdconvergedabsolute_             SVDCONVERGEDABSOLUTE
     34: #define svdconvergedrelative_             SVDCONVERGEDRELATIVE
     35: #define svdconvergednorm_                 SVDCONVERGEDNORM
     36: #define svdconvergedmaxit_                SVDCONVERGEDMAXIT
     37: #define svdsetconvergencetestfunction_    SVDSETCONVERGENCETESTFUNCTION
     38: #define svdsetstoppingtestfunction_       SVDSETSTOPPINGTESTFUNCTION
     39: #define svdgetdimensions000_              SVDGETDIMENSIONS000
     40: #define svdgetdimensions100_              SVDGETDIMENSIONS100
     41: #define svdgetdimensions010_              SVDGETDIMENSIONS010
     42: #define svdgetdimensions001_              SVDGETDIMENSIONS001
     43: #define svdgetdimensions110_              SVDGETDIMENSIONS110
     44: #define svdgetdimensions011_              SVDGETDIMENSIONS011
     45: #define svdgetdimensions101_              SVDGETDIMENSIONS101
     46: #define svdgetsingulartriplet0_           SVDGETSINGULARTRIPLET0
     47: #define svdgetsingulartriplet1_           SVDGETSINGULARTRIPLET1
     48: #define svdgettolerances00_               SVDGETTOLERANCES00
     49: #define svdgettolerances10_               SVDGETTOLERANCES10
     50: #define svdgettolerances01_               SVDGETTOLERANCES01
     51: #define svdsetinitialspaces00_            SVDSETINITIALSPACES00
     52: #define svdsetinitialspaces01_            SVDSETINITIALSPACES01
     53: #define svdsetinitialspaces10_            SVDSETINITIALSPACES10
     54: #define svdsetinitialspaces11_            SVDSETINITIALSPACES11
     55: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
     56: #define svddestroy_                       svddestroy
     57: #define svdview_                          svdview
     58: #define svderrorview_                     svderrorview
     59: #define svdconvergedreasonview_           svdconvergedreasonview
     60: #define svdvaluesview_                    svdvaluesview
     61: #define svdvectorsview_                   svdvectorsview
     62: #define svdsettype_                       svdsettype
     63: #define svdgettype_                       svdgettype
     64: #define svdmonitorset_                    svdmonitorset
     65: #define svdmonitorall_                    svdmonitorall
     66: #define svdmonitorfirst_                  svdmonitorfirst
     67: #define svdmonitorconditioning_           svdmonitorconditioning
     68: #define svdmonitorconverged_              svdmonitorconverged
     69: #define svdmonitorconvergedcreate_        svdmonitorconvergedcreate
     70: #define svdmonitorconvergeddestroy_       svdmonitorconvergeddestroy
     71: #define svdsetoptionsprefix_              svdsetoptionsprefix
     72: #define svdappendoptionsprefix_           svdappendoptionsprefix
     73: #define svdgetoptionsprefix_              svdgetoptionsprefix
     74: #define svdconvergedabsolute_             svdconvergedabsolute
     75: #define svdconvergedrelative_             svdconvergedrelative
     76: #define svdconvergednorm_                 svdconvergednorm
     77: #define svdconvergedmaxit_                svdconvergedmaxit
     78: #define svdsetconvergencetestfunction_    svdsetconvergencetestfunction
     79: #define svdsetstoppingtestfunction_       svdsetstoppingtestfunction
     80: #define svdgetdimensions000_              svdgetdimensions000
     81: #define svdgetdimensions100_              svdgetdimensions100
     82: #define svdgetdimensions010_              svdgetdimensions010
     83: #define svdgetdimensions001_              svdgetdimensions001
     84: #define svdgetdimensions110_              svdgetdimensions110
     85: #define svdgetdimensions011_              svdgetdimensions011
     86: #define svdgetdimensions101_              svdgetdimensions101
     87: #define svdgetsingulartriplet0_           svdgetsingulartriplet0
     88: #define svdgetsingulartriplet1_           svdgetsingulartriplet1
     89: #define svdgettolerances00_               svdgettolerances00
     90: #define svdgettolerances10_               svdgettolerances10
     91: #define svdgettolerances01_               svdgettolerances01
     92: #define svdsetinitialspaces00_            svdsetinitialspaces00
     93: #define svdsetinitialspaces01_            svdsetinitialspaces01
     94: #define svdsetinitialspaces10_            svdsetinitialspaces10
     95: #define svdsetinitialspaces11_            svdsetinitialspaces11
     96: #endif

     98: /*
     99:    These are not usually called from Fortran but allow Fortran users
    100:    to transparently set these monitors from .F code
    101: */
    102: SLEPC_EXTERN void svdmonitorall_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    103: {
    104:   *ierr = SVDMonitorAll(*svd,*it,*nconv,sigma,errest,*nest,*vf);
    105: }

    107: SLEPC_EXTERN void svdmonitorfirst_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    108: {
    109:   *ierr = SVDMonitorFirst(*svd,*it,*nconv,sigma,errest,*nest,*vf);
    110: }

    112: SLEPC_EXTERN void svdmonitorconditioning_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    113: {
    114:   *ierr = SVDMonitorConditioning(*svd,*it,*nconv,sigma,errest,*nest,*vf);
    115: }

    117: SLEPC_EXTERN void svdmonitorconverged_(SVD *svd,PetscInt *it,PetscInt *nconv,PetscReal *sigma,PetscReal *errest,PetscInt *nest,PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    118: {
    119:   *ierr = SVDMonitorConverged(*svd,*it,*nconv,sigma,errest,*nest,*vf);
    120: }

    122: SLEPC_EXTERN void svdmonitorconvergedcreate_(PetscViewer *vin,PetscViewerFormat *format,void *ctx,PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    123: {
    124:   PetscViewer v;
    125:   PetscPatchDefaultViewers_Fortran(vin,v);
    126:   CHKFORTRANNULLOBJECT(ctx);
    127:   *ierr = SVDMonitorConvergedCreate(v,*format,ctx,vf);
    128: }

    130: SLEPC_EXTERN void svdmonitorconvergeddestroy_(PetscViewerAndFormat **vf,PetscErrorCode *ierr)
    131: {
    132:   *ierr = SVDMonitorConvergedDestroy(vf);
    133: }

    135: static struct {
    136:   PetscFortranCallbackId monitor;
    137:   PetscFortranCallbackId monitordestroy;
    138:   PetscFortranCallbackId convergence;
    139:   PetscFortranCallbackId convdestroy;
    140:   PetscFortranCallbackId stopping;
    141:   PetscFortranCallbackId stopdestroy;
    142: } _cb;

    144: /* These are not extern C because they are passed into non-extern C user level functions */
    145: static PetscErrorCode ourmonitor(SVD svd,PetscInt i,PetscInt nc,PetscReal *sigma,PetscReal *d,PetscInt l,void* ctx)
    146: {
    147:   PetscObjectUseFortranCallback(svd,_cb.monitor,(SVD*,PetscInt*,PetscInt*,PetscReal*,PetscReal*,PetscInt*,void*,PetscErrorCode*),(&svd,&i,&nc,sigma,d,&l,_ctx,&ierr));
    148: }

    150: static PetscErrorCode ourdestroy(void** ctx)
    151: {
    152:   SVD svd = (SVD)*ctx;
    153:   PetscObjectUseFortranCallback(svd,_cb.monitordestroy,(void*,PetscErrorCode*),(_ctx,&ierr));
    154: }

    156: static PetscErrorCode ourconvergence(SVD svd,PetscReal sigma,PetscReal res,PetscReal *errest,void *ctx)
    157: {
    158:   PetscObjectUseFortranCallback(svd,_cb.convergence,(SVD*,PetscReal*,PetscReal*,PetscReal*,void*,PetscErrorCode*),(&svd,&sigma,&res,errest,_ctx,&ierr));
    159: }

    161: static PetscErrorCode ourconvdestroy(void *ctx)
    162: {
    163:   SVD svd = (SVD)ctx;
    164:   PetscObjectUseFortranCallback(svd,_cb.convdestroy,(void*,PetscErrorCode*),(_ctx,&ierr));
    165: }

    167: static PetscErrorCode ourstopping(SVD svd,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nsv,SVDConvergedReason *reason,void *ctx)
    168: {
    169:   PetscObjectUseFortranCallback(svd,_cb.stopping,(SVD*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,SVDConvergedReason*,void*,PetscErrorCode*),(&svd,&its,&max_it,&nconv,&nsv,reason,_ctx,&ierr));
    170: }

    172: static PetscErrorCode ourstopdestroy(void *ctx)
    173: {
    174:   SVD svd = (SVD)ctx;
    175:   PetscObjectUseFortranCallback(svd,_cb.stopdestroy,(void*,PetscErrorCode*),(_ctx,&ierr));
    176: }

    178: SLEPC_EXTERN void svddestroy_(SVD *svd,PetscErrorCode *ierr)
    179: {
    180:   PETSC_FORTRAN_OBJECT_F_DESTROYED_TO_C_NULL(svd);
    181:   *ierr = SVDDestroy(svd); if (*ierr) return;
    182:   PETSC_FORTRAN_OBJECT_C_NULL_TO_F_DESTROYED(svd);
    183: }

    185: SLEPC_EXTERN void svdview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)
    186: {
    187:   PetscViewer v;
    188:   PetscPatchDefaultViewers_Fortran(viewer,v);
    189:   *ierr = SVDView(*svd,v);
    190: }

    192: SLEPC_EXTERN void svdconvergedreasonview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)
    193: {
    194:   PetscViewer v;
    195:   PetscPatchDefaultViewers_Fortran(viewer,v);
    196:   *ierr = SVDConvergedReasonView(*svd,v);
    197: }

    199: SLEPC_EXTERN void svderrorview_(SVD *svd,SVDErrorType *etype,PetscViewer *viewer,PetscErrorCode *ierr)
    200: {
    201:   PetscViewer v;
    202:   PetscPatchDefaultViewers_Fortran(viewer,v);
    203:   *ierr = SVDErrorView(*svd,*etype,v);
    204: }

    206: SLEPC_EXTERN void svdvaluesview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)
    207: {
    208:   PetscViewer v;
    209:   PetscPatchDefaultViewers_Fortran(viewer,v);
    210:   *ierr = SVDValuesView(*svd,v);
    211: }

    213: SLEPC_EXTERN void svdvectorsview_(SVD *svd,PetscViewer *viewer,PetscErrorCode *ierr)
    214: {
    215:   PetscViewer v;
    216:   PetscPatchDefaultViewers_Fortran(viewer,v);
    217:   *ierr = SVDVectorsView(*svd,v);
    218: }

    220: SLEPC_EXTERN void svdsettype_(SVD *svd,char *type,PetscErrorCode *ierr,PETSC_FORTRAN_CHARLEN_T len)
    221: {
    222:   char *t;

    224:   FIXCHAR(type,len,t);
    225:   *ierr = SVDSetType(*svd,t);if (*ierr) return;
    226:   FREECHAR(type,t);
    227: }

    229: SLEPC_EXTERN void svdgettype_(SVD *svd,char *name,PetscErrorCode *ierr,PETSC_FORTRAN_CHARLEN_T len)
    230: {
    231:   SVDType tname;

    233:   *ierr = SVDGetType(*svd,&tname);if (*ierr) return;
    234:   *ierr = PetscStrncpy(name,tname,len);if (*ierr) return;
    235:   FIXRETURNCHAR(PETSC_TRUE,name,len);
    236: }

    238: SLEPC_EXTERN void svdmonitorset_(SVD *svd,void (*monitor)(SVD*,PetscInt*,PetscInt*,PetscReal*,PetscReal*,PetscInt*,void*,PetscErrorCode*),void *mctx,void (*monitordestroy)(void *,PetscErrorCode*),PetscErrorCode *ierr)
    239: {
    240:   CHKFORTRANNULLOBJECT(mctx);
    241:   CHKFORTRANNULLFUNCTION(monitordestroy);
    242:   if ((PetscVoidFunction)monitor == (PetscVoidFunction)svdmonitorall_) {
    243:     *ierr = SVDMonitorSet(*svd,(PetscErrorCode (*)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*))SVDMonitorAll,*(PetscViewerAndFormat**)mctx,(PetscErrorCode (*)(void**))PetscViewerAndFormatDestroy);
    244:   } else if ((PetscVoidFunction)monitor == (PetscVoidFunction)svdmonitorconverged_) {
    245:     *ierr = SVDMonitorSet(*svd,(PetscErrorCode (*)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*))SVDMonitorConverged,*(PetscViewerAndFormat**)mctx,(PetscErrorCode (*)(void**))SVDMonitorConvergedDestroy);
    246:   } else if ((PetscVoidFunction)monitor == (PetscVoidFunction)svdmonitorfirst_) {
    247:     *ierr = SVDMonitorSet(*svd,(PetscErrorCode (*)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*))SVDMonitorFirst,*(PetscViewerAndFormat**)mctx,(PetscErrorCode (*)(void**))PetscViewerAndFormatDestroy);
    248:   } else {
    249:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.monitor,(PetscVoidFunction)monitor,mctx); if (*ierr) return;
    250:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.monitordestroy,(PetscVoidFunction)monitordestroy,mctx); if (*ierr) return;
    251:     *ierr = SVDMonitorSet(*svd,ourmonitor,*svd,ourdestroy);
    252:   }
    253: }

    255: SLEPC_EXTERN void svdsetoptionsprefix_(SVD *svd,char *prefix,PetscErrorCode *ierr,PETSC_FORTRAN_CHARLEN_T len)
    256: {
    257:   char *t;

    259:   FIXCHAR(prefix,len,t);
    260:   *ierr = SVDSetOptionsPrefix(*svd,t);if (*ierr) return;
    261:   FREECHAR(prefix,t);
    262: }

    264: SLEPC_EXTERN void svdappendoptionsprefix_(SVD *svd,char *prefix,PetscErrorCode *ierr,PETSC_FORTRAN_CHARLEN_T len)
    265: {
    266:   char *t;

    268:   FIXCHAR(prefix,len,t);
    269:   *ierr = SVDAppendOptionsPrefix(*svd,t);if (*ierr) return;
    270:   FREECHAR(prefix,t);
    271: }

    273: SLEPC_EXTERN void svdgetoptionsprefix_(SVD *svd,char *prefix,PetscErrorCode *ierr,PETSC_FORTRAN_CHARLEN_T len)
    274: {
    275:   const char *tname;

    277:   *ierr = SVDGetOptionsPrefix(*svd,&tname); if (*ierr) return;
    278:   *ierr = PetscStrncpy(prefix,tname,len);if (*ierr) return;
    279:   FIXRETURNCHAR(PETSC_TRUE,prefix,len);
    280: }

    282: SLEPC_EXTERN void svdconvergedabsolute_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)
    283: {
    284:   *ierr = SVDConvergedAbsolute(*svd,*sigma,*res,errest,ctx);
    285: }

    287: SLEPC_EXTERN void svdconvergedrelative_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)
    288: {
    289:   *ierr = SVDConvergedRelative(*svd,*sigma,*res,errest,ctx);
    290: }

    292: SLEPC_EXTERN void svdconvergednorm_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)
    293: {
    294:   *ierr = SVDConvergedNorm(*svd,*sigma,*res,errest,ctx);
    295: }

    297: SLEPC_EXTERN void svdconvergedmaxit_(SVD *svd,PetscReal *sigma,PetscReal *res,PetscReal *errest,void *ctx,PetscErrorCode *ierr)
    298: {
    299:   *ierr = SVDConvergedMaxIt(*svd,*sigma,*res,errest,ctx);
    300: }

    302: SLEPC_EXTERN void svdsetconvergencetestfunction_(SVD *svd,void (*func)(SVD*,PetscReal*,PetscReal*,PetscReal*,void*,PetscErrorCode*),void* ctx,void (*destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)
    303: {
    304:   CHKFORTRANNULLOBJECT(ctx);
    305:   CHKFORTRANNULLFUNCTION(destroy);
    306:   if ((PetscVoidFunction)func == (PetscVoidFunction)svdconvergedabsolute_) {
    307:     *ierr = SVDSetConvergenceTest(*svd,SVD_CONV_ABS);
    308:   } else if ((PetscVoidFunction)func == (PetscVoidFunction)svdconvergedrelative_) {
    309:     *ierr = SVDSetConvergenceTest(*svd,SVD_CONV_REL);
    310:   } else if ((PetscVoidFunction)func == (PetscVoidFunction)svdconvergednorm_) {
    311:     *ierr = SVDSetConvergenceTest(*svd,SVD_CONV_NORM);
    312:   } else if ((PetscVoidFunction)func == (PetscVoidFunction)svdconvergedmaxit_) {
    313:     *ierr = SVDSetConvergenceTest(*svd,SVD_CONV_MAXIT);
    314:   } else {
    315:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.convergence,(PetscVoidFunction)func,ctx); if (*ierr) return;
    316:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.convdestroy,(PetscVoidFunction)destroy,ctx); if (*ierr) return;
    317:     *ierr = SVDSetConvergenceTestFunction(*svd,ourconvergence,*svd,ourconvdestroy);
    318:   }
    319: }

    321: SLEPC_EXTERN void svdstoppingbasic_(SVD *svd,PetscInt *its,PetscInt *max_it,PetscInt *nconv,PetscInt *nsv,SVDConvergedReason *reason,void *ctx,PetscErrorCode *ierr)
    322: {
    323:   *ierr = SVDStoppingBasic(*svd,*its,*max_it,*nconv,*nsv,reason,ctx);
    324: }

    326: SLEPC_EXTERN void svdsetstoppingtestfunction_(SVD *svd,void (*func)(SVD*,PetscInt,PetscInt,PetscInt,PetscInt,SVDConvergedReason*,void*,PetscErrorCode*),void* ctx,void (*destroy)(void*,PetscErrorCode*),PetscErrorCode *ierr)
    327: {
    328:   CHKFORTRANNULLOBJECT(ctx);
    329:   CHKFORTRANNULLFUNCTION(destroy);
    330:   if ((PetscVoidFunction)func == (PetscVoidFunction)svdstoppingbasic_) {
    331:     *ierr = SVDSetStoppingTest(*svd,SVD_STOP_BASIC);
    332:   } else {
    333:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.stopping,(PetscVoidFunction)func,ctx); if (*ierr) return;
    334:     *ierr = PetscObjectSetFortranCallback((PetscObject)*svd,PETSC_FORTRAN_CALLBACK_CLASS,&_cb.stopdestroy,(PetscVoidFunction)destroy,ctx); if (*ierr) return;
    335:     *ierr = SVDSetStoppingTestFunction(*svd,ourstopping,*svd,ourstopdestroy);
    336:   }
    337: }

    339: SLEPC_EXTERN void svdgetdimensions_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    340: {
    341:   CHKFORTRANNULLINTEGER(nev);
    342:   CHKFORTRANNULLINTEGER(ncv);
    343:   CHKFORTRANNULLINTEGER(mpd);
    344:   *ierr = SVDGetDimensions(*svd,nev,ncv,mpd);
    345: }

    347: SLEPC_EXTERN void svdgetdimensions000_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    348: {
    349:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    350: }

    352: SLEPC_EXTERN void svdgetdimensions100_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    353: {
    354:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    355: }

    357: SLEPC_EXTERN void svdgetdimensions010_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    358: {
    359:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    360: }

    362: SLEPC_EXTERN void svdgetdimensions001_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    363: {
    364:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    365: }

    367: SLEPC_EXTERN void svdgetdimensions110_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    368: {
    369:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    370: }

    372: SLEPC_EXTERN void svdgetdimensions011_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    373: {
    374:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    375: }

    377: SLEPC_EXTERN void svdgetdimensions101_(SVD *svd,PetscInt *nev,PetscInt *ncv,PetscInt *mpd,PetscErrorCode *ierr)
    378: {
    379:   svdgetdimensions_(svd,nev,ncv,mpd,ierr);
    380: }

    382: SLEPC_EXTERN void svdgetsingulartriplet_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v,PetscErrorCode *ierr)
    383: {
    384:   CHKFORTRANNULLREAL(sigma);
    385:   *ierr = SVDGetSingularTriplet(*svd,*i,sigma,*u,*v);
    386: }

    388: SLEPC_EXTERN void svdgetsingulartriplet0_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v, PetscErrorCode *ierr)
    389: {
    390:   svdgetsingulartriplet_(svd,i,sigma,u,v,ierr);
    391: }

    393: SLEPC_EXTERN void svdgetsingulartriplet1_(SVD *svd,PetscInt *i,PetscReal *sigma,Vec *u,Vec *v, PetscErrorCode *ierr)
    394: {
    395:   svdgetsingulartriplet_(svd,i,sigma,u,v,ierr);
    396: }

    398: SLEPC_EXTERN void svdgettolerances_(SVD *svd,PetscReal *tol,PetscInt *maxits,PetscErrorCode *ierr)
    399: {
    400:   CHKFORTRANNULLREAL(tol);
    401:   CHKFORTRANNULLINTEGER(maxits);
    402:   *ierr = SVDGetTolerances(*svd,tol,maxits);
    403: }

    405: SLEPC_EXTERN void svdgettolerances00_(SVD *svd,PetscReal *tol,PetscInt *maxits,PetscErrorCode *ierr)
    406: {
    407:   svdgettolerances_(svd,tol,maxits,ierr);
    408: }

    410: SLEPC_EXTERN void svdgettolerances10_(SVD *svd,PetscReal *tol,PetscInt *maxits,PetscErrorCode *ierr)
    411: {
    412:   svdgettolerances_(svd,tol,maxits,ierr);
    413: }

    415: SLEPC_EXTERN void svdgettolerances01_(SVD *svd,PetscReal *tol,PetscInt *maxits,PetscErrorCode *ierr)
    416: {
    417:   svdgettolerances_(svd,tol,maxits,ierr);
    418: }

    420: SLEPC_EXTERN void svdsetinitialspaces_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,PetscErrorCode *ierr)
    421: {
    422:   CHKFORTRANNULLOBJECT(isr);
    423:   CHKFORTRANNULLOBJECT(isl);
    424:   *ierr = SVDSetInitialSpaces(*svd,*nr,isr,*nl,isl);
    425: }

    427: SLEPC_EXTERN void svdsetinitialspaces00_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,PetscErrorCode *ierr)
    428: {
    429:   svdsetinitialspaces_(svd,nr,isr,nl,isl,ierr);
    430: }

    432: SLEPC_EXTERN void svdsetinitialspaces01_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,PetscErrorCode *ierr)
    433: {
    434:   svdsetinitialspaces_(svd,nr,isr,nl,isl,ierr);
    435: }

    437: SLEPC_EXTERN void svdsetinitialspaces10_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,PetscErrorCode *ierr)
    438: {
    439:   svdsetinitialspaces_(svd,nr,isr,nl,isl,ierr);
    440: }

    442: SLEPC_EXTERN void svdsetinitialspaces11_(SVD *svd,PetscInt *nr,Vec *isr,PetscInt *nl,Vec *isl,PetscErrorCode *ierr)
    443: {
    444:   svdsetinitialspaces_(svd,nr,isr,nl,isl,ierr);
    445: }