Date: 2018-10-23T10:32:54+00:00

Actual source code: slepcnep.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 NEPGetDimensions
     11:         subroutine NEPGetDimensions000(a,b,c,d,z)
     12:         use slepcnepdef
     13:           NEP a
     14:           PetscInt b
     15:           PetscInt c
     16:           PetscInt d
     17:           integer z
     18:         end subroutine
     19:         subroutine NEPGetDimensions100(a,b,c,d,z)
     20:         use slepcnepdef
     21:           NEP a
     22:           PetscInt b(*)
     23:           PetscInt c
     24:           PetscInt d
     25:           integer z
     26:         end subroutine
     27:         subroutine NEPGetDimensions010(a,b,c,d,z)
     28:         use slepcnepdef
     29:           NEP a
     30:           PetscInt b
     31:           PetscInt c(*)
     32:           PetscInt d
     33:           integer z
     34:         end subroutine
     35:         subroutine NEPGetDimensions001(a,b,c,d,z)
     36:         use slepcnepdef
     37:           NEP a
     38:           PetscInt b
     39:           PetscInt c
     40:           PetscInt d(*)
     41:           integer z
     42:         end subroutine
     43:         subroutine NEPGetDimensions110(a,b,c,d,z)
     44:         use slepcnepdef
     45:           NEP a
     46:           PetscInt b(*)
     47:           PetscInt c(*)
     48:           PetscInt d
     49:           integer z
     50:         end subroutine
     51:         subroutine NEPGetDimensions011(a,b,c,d,z)
     52:         use slepcnepdef
     53:           NEP a
     54:           PetscInt b
     55:           PetscInt c(*)
     56:           PetscInt d(*)
     57:           integer z
     58:         end subroutine
     59:         subroutine NEPGetDimensions101(a,b,c,d,z)
     60:         use slepcnepdef
     61:           NEP a
     62:           PetscInt b(*)
     63:           PetscInt c
     64:           PetscInt d(*)
     65:           integer z
     66:         end subroutine
     67:         end interface NEPGetDimensions

     69:       interface NEPGetEigenpair
     70:         subroutine NEPGetEigenpair00(a,b,c,d,e,f,z)
     71:           use slepcnepdef
     72:           NEP a
     73:           PetscInt b
     74:           PetscScalar c
     75:           PetscScalar d
     76:           Vec e
     77:           Vec f
     78:           integer z
     79:         end subroutine
     80:         subroutine NEPGetEigenpair10(a,b,c,d,e,f,z)
     81:           use slepcnepdef
     82:           NEP a
     83:           PetscInt b
     84:           PetscScalar c(*)
     85:           PetscScalar d
     86:           Vec e
     87:           Vec f
     88:           integer z
     89:         end subroutine
     90:         subroutine NEPGetEigenpair01(a,b,c,d,e,f,z)
     91:           use slepcnepdef
     92:           NEP a
     93:           PetscInt b
     94:           PetscScalar c
     95:           PetscScalar d(*)
     96:           Vec e
     97:           Vec f
     98:           integer z
     99:         end subroutine
    100:         subroutine NEPGetEigenpair11(a,b,c,d,e,f,z)
    101:           use slepcnepdef
    102:           NEP 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 NEPGetEigenpair

    112:       interface NEPGetTolerances
    113:         subroutine NEPGetTolerances00(a,b,c,z)
    114:           use slepcnepdef
    115:           NEP a
    116:           PetscReal b
    117:           PetscInt c
    118:           integer z
    119:         end subroutine
    120:         subroutine NEPGetTolerances10(a,b,c,z)
    121:           use slepcnepdef
    122:           NEP a
    123:           PetscReal b(*)
    124:           PetscInt c
    125:           integer z
    126:         end subroutine
    127:         subroutine NEPGetTolerances01(a,b,c,z)
    128:           use slepcnepdef
    129:           NEP a
    130:           PetscReal b
    131:           PetscInt c(*)
    132:           integer z
    133:         end subroutine
    134:       end interface NEPGetTolerances

    136:       interface NEPGetRefine
    137:         subroutine NEPGetRefine000(a,b,c,d,e,f,z)
    138:           use slepcnepdef
    139:           NEP a
    140:           NEPRefine b
    141:           PetscInt c
    142:           PetscReal d
    143:           PetscInt e
    144:           NEPRefineScheme f
    145:           integer z
    146:         end subroutine
    147:         subroutine NEPGetRefine100(a,b,c,d,e,f,z)
    148:           use slepcnepdef
    149:           NEP a
    150:           NEPRefine b
    151:           PetscInt c(*)
    152:           PetscReal d
    153:           PetscInt e
    154:           NEPRefineScheme f
    155:           integer z
    156:         end subroutine
    157:         subroutine NEPGetRefine010(a,b,c,d,e,f,z)
    158:           use slepcnepdef
    159:           NEP a
    160:           NEPRefine b
    161:           PetscInt c
    162:           PetscReal d(*)
    163:           PetscInt e
    164:           NEPRefineScheme f
    165:           integer z
    166:         end subroutine
    167:         subroutine NEPGetRefine001(a,b,c,d,e,f,z)
    168:           use slepcnepdef
    169:           NEP a
    170:           NEPRefine b
    171:           PetscInt c
    172:           PetscReal d
    173:           PetscInt e(*)
    174:           NEPRefineScheme f
    175:           integer z
    176:         end subroutine
    177:         subroutine NEPGetRefine110(a,b,c,d,e,f,z)
    178:           use slepcnepdef
    179:           NEP a
    180:           NEPRefine b
    181:           PetscInt c(*)
    182:           PetscReal d(*)
    183:           PetscInt e
    184:           NEPRefineScheme f
    185:           integer z
    186:         end subroutine
    187:         subroutine NEPGetRefine011(a,b,c,d,e,f,z)
    188:           use slepcnepdef
    189:           NEP a
    190:           NEPRefine b
    191:           PetscInt c
    192:           PetscReal d(*)
    193:           PetscInt e(*)
    194:           NEPRefineScheme f
    195:           integer z
    196:         end subroutine
    197:         subroutine NEPGetRefine101(a,b,c,d,e,f,z)
    198:           use slepcnepdef
    199:           NEP a
    200:           NEPRefine b
    201:           PetscInt c(*)
    202:           PetscReal d
    203:           PetscInt e(*)
    204:           NEPRefineScheme f
    205:           integer z
    206:         end subroutine
    207:         subroutine NEPGetRefine111(a,b,c,d,e,f,z)
    208:           use slepcnepdef
    209:           NEP a
    210:           NEPRefine b
    211:           PetscInt c(*)
    212:           PetscReal d(*)
    213:           PetscInt e(*)
    214:           NEPRefineScheme f
    215:           integer z
    216:         end subroutine
    217:       end interface NEPGetRefine

    219:       interface NEPSetInitialSpace
    220:         subroutine NEPSetInitialSpace0(a,b,c,z)
    221:           use slepcnepdef
    222:           NEP a
    223:           PetscInt b
    224:           Vec c
    225:           integer z
    226:         end subroutine
    227:         subroutine NEPSetInitialSpace1(a,b,c,z)
    228:           use slepcnepdef
    229:           NEP a
    230:           PetscInt b
    231:           Vec c(*)
    232:           integer z
    233:         end subroutine
    234:       end interface NEPSetInitialSpace