Actual source code: slepcpep.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 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