Actual source code: slepcpep.h90

slepc-3.15.1 2021-05-28
Report Typos and Errors
  1: !
  2: !  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3: !  SLEPc - Scalable Library for Eigenvalue Problem Computations
  4: !  Copyright (c) 2002-2021, 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:           import tPEP
 13:           PEP a
 14:           PetscInt b
 15:           PetscInt c
 16:           PetscInt d
 17:           PetscErrorCode z
 18:         end subroutine
 19:         subroutine PEPGetDimensions100(a,b,c,d,z)
 20:           import tPEP
 21:           PEP a
 22:           PetscInt b(*)
 23:           PetscInt c
 24:           PetscInt d
 25:           PetscErrorCode z
 26:         end subroutine
 27:         subroutine PEPGetDimensions010(a,b,c,d,z)
 28:           import tPEP
 29:           PEP a
 30:           PetscInt b
 31:           PetscInt c(*)
 32:           PetscInt d
 33:           PetscErrorCode z
 34:         end subroutine
 35:         subroutine PEPGetDimensions001(a,b,c,d,z)
 36:           import tPEP
 37:           PEP a
 38:           PetscInt b
 39:           PetscInt c
 40:           PetscInt d(*)
 41:           PetscErrorCode z
 42:         end subroutine
 43:         subroutine PEPGetDimensions110(a,b,c,d,z)
 44:           import tPEP
 45:           PEP a
 46:           PetscInt b(*)
 47:           PetscInt c(*)
 48:           PetscInt d
 49:           PetscErrorCode z
 50:         end subroutine
 51:         subroutine PEPGetDimensions011(a,b,c,d,z)
 52:           import tPEP
 53:           PEP a
 54:           PetscInt b
 55:           PetscInt c(*)
 56:           PetscInt d(*)
 57:           PetscErrorCode z
 58:         end subroutine
 59:         subroutine PEPGetDimensions101(a,b,c,d,z)
 60:           import tPEP
 61:           PEP a
 62:           PetscInt b(*)
 63:           PetscInt c
 64:           PetscInt d(*)
 65:           PetscErrorCode z
 66:         end subroutine
 67:         end interface PEPGetDimensions

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

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

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

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

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