Actual source code: slepcnep.h90

slepc-3.11.2 2019-07-30
Report Typos and Errors
  1: !
  2: !  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3: !  SLEPc - Scalable Library for Eigenvalue Problem Computations
  4: !  Copyright (c) 2002-2019, 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