Actual source code: slepcpep.h90
slepc-3.10.1 2018-10-23
Report Typos and Errors

      1: !
      2: !  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3: !  SLEPc - Scalable Library for Eigenvalue Problem Computations
      4: !  Copyright (c) 2002-2018, Universitat Politecnica de Valencia, Spain
      5: !
      6: !  This file is part of SLEPc.
      7: !  SLEPc is distributed under a 2-clause BSD license (see LICENSE).
      8: !  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      9: !
     10:       interface PEPGetDimensions
     11:         subroutine PEPGetDimensions000(a,b,c,d,z)
     12:         use slepcpepdef
     13:           PEP a
     14:           PetscInt b
     15:           PetscInt c
     16:           PetscInt d
     17:           integer z
     18:         end subroutine
     19:         subroutine PEPGetDimensions100(a,b,c,d,z)
     20:         use slepcpepdef
     21:           PEP a
     22:           PetscInt b(*)
     23:           PetscInt c
     24:           PetscInt d
     25:           integer z
     26:         end subroutine
     27:         subroutine PEPGetDimensions010(a,b,c,d,z)
     28:         use slepcpepdef
     29:           PEP a
     30:           PetscInt b
     31:           PetscInt c(*)
     32:           PetscInt d
     33:           integer z
     34:         end subroutine
     35:         subroutine PEPGetDimensions001(a,b,c,d,z)
     36:         use slepcpepdef
     37:           PEP a
     38:           PetscInt b
     39:           PetscInt c
     40:           PetscInt d(*)
     41:           integer z
     42:         end subroutine
     43:         subroutine PEPGetDimensions110(a,b,c,d,z)
     44:         use slepcpepdef
     45:           PEP a
     46:           PetscInt b(*)
     47:           PetscInt c(*)
     48:           PetscInt d
     49:           integer z
     50:         end subroutine
     51:         subroutine PEPGetDimensions011(a,b,c,d,z)
     52:         use slepcpepdef
     53:           PEP a
     54:           PetscInt b
     55:           PetscInt c(*)
     56:           PetscInt d(*)
     57:           integer z
     58:         end subroutine
     59:         subroutine PEPGetDimensions101(a,b,c,d,z)
     60:         use slepcpepdef
     61:           PEP a
     62:           PetscInt b(*)
     63:           PetscInt c
     64:           PetscInt d(*)
     65:           integer z
     66:         end subroutine
     67:         end interface PEPGetDimensions

     69:       interface PEPGetEigenpair
     70:         subroutine PEPGetEigenpair00(a,b,c,d,e,f,z)
     71:           use slepcpepdef
     72:           PEP a
     73:           PetscInt b
     74:           PetscScalar c
     75:           PetscScalar d
     76:           Vec e
     77:           Vec f
     78:           integer z
     79:         end subroutine
     80:         subroutine PEPGetEigenpair10(a,b,c,d,e,f,z)
     81:           use slepcpepdef
     82:           PEP a
     83:           PetscInt b
     84:           PetscScalar c(*)
     85:           PetscScalar d
     86:           Vec e
     87:           Vec f
     88:           integer z
     89:         end subroutine
     90:         subroutine PEPGetEigenpair01(a,b,c,d,e,f,z)
     91:           use slepcpepdef
     92:           PEP a
     93:           PetscInt b
     94:           PetscScalar c
     95:           PetscScalar d(*)
     96:           Vec e
     97:           Vec f
     98:           integer z
     99:         end subroutine
    100:         subroutine PEPGetEigenpair11(a,b,c,d,e,f,z)
    101:           use slepcpepdef
    102:           PEP a
    103:           PetscInt b
    104:           PetscScalar c(*)
    105:           PetscScalar d(*)
    106:           Vec e
    107:           Vec f
    108:           integer z
    109:         end subroutine
    110:       end interface PEPGetEigenpair

    112:       interface PEPGetTolerances
    113:         subroutine PEPGetTolerances00(a,b,c,z)
    114:           use slepcpepdef
    115:           PEP a
    116:           PetscReal b
    117:           PetscInt c
    118:           integer z
    119:         end subroutine
    120:         subroutine PEPGetTolerances10(a,b,c,z)
    121:           use slepcpepdef
    122:           PEP a
    123:           PetscReal b(*)
    124:           PetscInt c
    125:           integer z
    126:         end subroutine
    127:         subroutine PEPGetTolerances01(a,b,c,z)
    128:           use slepcpepdef
    129:           PEP a
    130:           PetscReal b
    131:           PetscInt c(*)
    132:           integer z
    133:         end subroutine
    134:       end interface PEPGetTolerances

    136:       interface PEPGetScale
    137:         subroutine PEPGetScale000(a,b,c,d,e,f,g,z)
    138:           use slepcpepdef
    139:           PEP a
    140:           PEPScale b
    141:           PetscReal c
    142:           Vec d,e
    143:           PetscInt f
    144:           PetscReal g
    145:           integer z
    146:         end subroutine
    147:         subroutine PEPGetScale100(a,b,c,d,e,f,g,z)
    148:           use slepcpepdef
    149:           PEP a
    150:           PEPScale b
    151:           PetscReal c(*)
    152:           Vec d,e
    153:           PetscInt f
    154:           PetscReal g
    155:           integer z
    156:         end subroutine
    157:         subroutine PEPGetScale010(a,b,c,d,e,f,g,z)
    158:           use slepcpepdef
    159:           PEP a
    160:           PEPScale b
    161:           PetscReal c
    162:           Vec d,e
    163:           PetscInt f(*)
    164:           PetscReal g
    165:           integer z
    166:         end subroutine
    167:         subroutine PEPGetScale001(a,b,c,d,e,f,g,z)
    168:           use slepcpepdef
    169:           PEP a
    170:           PEPScale b
    171:           PetscReal c
    172:           Vec d,e
    173:           PetscInt f
    174:           PetscReal g(*)
    175:           integer z
    176:         end subroutine
    177:         subroutine PEPGetScale110(a,b,c,d,e,f,g,z)
    178:           use slepcpepdef
    179:           PEP a
    180:           PEPScale b
    181:           PetscReal c(*)
    182:           Vec d,e
    183:           PetscInt f(*)
    184:           PetscReal g
    185:           integer z
    186:         end subroutine
    187:         subroutine PEPGetScale011(a,b,c,d,e,f,g,z)
    188:           use slepcpepdef
    189:           PEP a
    190:           PEPScale b
    191:           PetscReal c
    192:           Vec d,e
    193:           PetscInt f(*)
    194:           PetscReal g(*)
    195:           integer z
    196:         end subroutine
    197:         subroutine PEPGetScale101(a,b,c,d,e,f,g,z)
    198:           use slepcpepdef
    199:           PEP a
    200:           PEPScale b
    201:           PetscReal c(*)
    202:           Vec d,e
    203:           PetscInt f
    204:           PetscReal g(*)
    205:           integer z
    206:         end subroutine
    207:         subroutine PEPGetScale111(a,b,c,d,e,f,g,z)
    208:           use slepcpepdef
    209:           PEP a
    210:           PEPScale b
    211:           PetscReal c(*)
    212:           Vec d,e
    213:           PetscInt f(*)
    214:           PetscReal g(*)
    215:           integer z
    216:         end subroutine
    217:       end interface PEPGetScale

    219:       interface PEPGetRefine
    220:         subroutine PEPGetRefine000(a,b,c,d,e,f,z)
    221:           use slepcpepdef
    222:           PEP a
    223:           PEPRefine b
    224:           PetscInt c
    225:           PetscReal d
    226:           PetscInt e
    227:           PEPRefineScheme f
    228:           integer z
    229:         end subroutine
    230:         subroutine PEPGetRefine100(a,b,c,d,e,f,z)
    231:           use slepcpepdef
    232:           PEP a
    233:           PEPRefine b
    234:           PetscInt c(*)
    235:           PetscReal d
    236:           PetscInt e
    237:           PEPRefineScheme f
    238:           integer z
    239:         end subroutine
    240:         subroutine PEPGetRefine010(a,b,c,d,e,f,z)
    241:           use slepcpepdef
    242:           PEP a
    243:           PEPRefine b
    244:           PetscInt c
    245:           PetscReal d(*)
    246:           PetscInt e
    247:           PEPRefineScheme f
    248:           integer z
    249:         end subroutine
    250:         subroutine PEPGetRefine001(a,b,c,d,e,f,z)
    251:           use slepcpepdef
    252:           PEP a
    253:           PEPRefine b
    254:           PetscInt c
    255:           PetscReal d
    256:           PetscInt e(*)
    257:           PEPRefineScheme f
    258:           integer z
    259:         end subroutine
    260:         subroutine PEPGetRefine110(a,b,c,d,e,f,z)
    261:           use slepcpepdef
    262:           PEP a
    263:           PEPRefine b
    264:           PetscInt c(*)
    265:           PetscReal d(*)
    266:           PetscInt e
    267:           PEPRefineScheme f
    268:           integer z
    269:         end subroutine
    270:         subroutine PEPGetRefine011(a,b,c,d,e,f,z)
    271:           use slepcpepdef
    272:           PEP a
    273:           PEPRefine b
    274:           PetscInt c
    275:           PetscReal d(*)
    276:           PetscInt e(*)
    277:           PEPRefineScheme f
    278:           integer z
    279:         end subroutine
    280:         subroutine PEPGetRefine101(a,b,c,d,e,f,z)
    281:           use slepcpepdef
    282:           PEP a
    283:           PEPRefine b
    284:           PetscInt c(*)
    285:           PetscReal d
    286:           PetscInt e(*)
    287:           PEPRefineScheme f
    288:           integer z
    289:         end subroutine
    290:         subroutine PEPGetRefine111(a,b,c,d,e,f,z)
    291:           use slepcpepdef
    292:           PEP a
    293:           PEPRefine b
    294:           PetscInt c(*)
    295:           PetscReal d(*)
    296:           PetscInt e(*)
    297:           PEPRefineScheme f
    298:           integer z
    299:         end subroutine
    300:       end interface PEPGetRefine

    302:       interface PEPSetInitialSpace
    303:         subroutine PEPSetInitialSpace0(a,b,c,z)
    304:           use slepcpepdef
    305:           PEP a
    306:           PetscInt b
    307:           Vec c
    308:           integer z
    309:         end subroutine
    310:         subroutine PEPSetInitialSpace1(a,b,c,z)
    311:           use slepcpepdef
    312:           PEP a
    313:           PetscInt b
    314:           Vec c(*)
    315:           integer z
    316:         end subroutine
    317:       end interface PEPSetInitialSpace