After an arpack update, eigs test has been updated.
[scilab.git] / scilab / modules / arnoldi / tests / unit_tests / eigs.tst
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // =============================================================================
7
8 // <-- CLI SHELL MODE -->
9
10 // unit tests for eigs function
11 // =============================================================================
12
13 // Interface
14 // =========
15 assert_checkfalse(execstr("eigs()"   ,"errcatch") == 0);
16 refMsg = msprintf(_("%s : Wrong number of input arguments : %d to %d expected.\n"), "eigs", 1, 6);
17 assert_checkerror("eigs()", refMsg);
18
19 assert_checkfalse(execstr("eigs(1)","errcatch") == 0);
20 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
21 assert_checkerror("eigs(1)", refMsg);
22
23 assert_checkfalse(execstr("eigs([])", "errcatch") == 0);
24 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
25 assert_checkerror("eigs([])", refMsg);
26
27 assert_checkfalse(execstr("eigs(%nan)", "errcatch") == 0);
28 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
29 assert_checkerror("eigs(%nan)", refMsg);
30
31 assert_checkfalse(execstr("eigs(%inf)", "errcatch") == 0);
32 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
33 assert_checkerror("eigs(%inf)", refMsg);
34
35 assert_checkfalse(execstr("eigs(%eps)", "errcatch") == 0);
36 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
37 assert_checkerror("eigs(%eps)", refMsg);
38
39 assert_checkfalse(execstr("eigs([%f %f])", "errcatch") == 0);
40 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
41 assert_checkerror("eigs([%f %f])", refMsg);
42
43 assert_checkfalse(execstr("eigs(sparse([%f %f]))", "errcatch") == 0);
44 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
45 assert_checkerror("eigs(sparse([%f %f]))", refMsg);
46
47 assert_checkfalse(execstr("eigs([1 2])", "errcatch") == 0);
48 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
49 assert_checkerror("eigs([1 2])", refMsg);
50
51 assert_checkfalse(execstr("eigs([1; 2])", "errcatch") == 0);
52 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
53 assert_checkerror("eigs([1; 2])", refMsg);
54
55 assert_checkfalse(execstr("eigs(sparse([1 2]))", "errcatch") == 0);
56 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
57 assert_checkerror("eigs(sparse([1 2]))", refMsg);
58
59 assert_checkfalse(execstr("eigs(sparse([1; 2]))", "errcatch") == 0);
60 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
61 assert_checkerror("eigs(sparse([1; 2]))", refMsg);
62
63
64 n = 20;
65 A            = diag(10*ones(n,1));
66 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
67 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
68
69 assert_checkfalse(execstr("eigs(A, %f)", "errcatch") == 0);
70 refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
71 assert_checkerror("eigs(A, %f)", refMsg);
72
73 assert_checkfalse(execstr("eigs(A, %nan)", "errcatch") == 0);
74 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
75 assert_checkerror("eigs(A, %nan)", refMsg);
76
77 assert_checkfalse(execstr("eigs(A, %inf)", "errcatch") == 0);
78 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
79 assert_checkerror("eigs(A, %inf)", refMsg);
80
81 assert_checkfalse(execstr("eigs(A, %eps)", "errcatch") == 0);
82 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
83 assert_checkerror("eigs(A, %eps)", refMsg);
84
85 assert_checkfalse(execstr("eigs(sparse(A), %f)", "errcatch") == 0);
86 refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
87 assert_checkerror("eigs(sparse(A), %f)", refMsg);
88
89 assert_checkfalse(execstr("eigs(sparse(A), %nan)", "errcatch") == 0);
90 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
91 assert_checkerror("eigs(sparse(A), %nan)", refMsg);
92
93 assert_checkfalse(execstr("eigs(sparse(A), %inf)", "errcatch") == 0);
94 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
95 assert_checkerror("eigs(sparse(A), %inf)", refMsg);
96
97 assert_checkfalse(execstr("eigs(sparse(A), %eps)", "errcatch") == 0);
98 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
99 assert_checkerror("eigs(sparse(A), %eps)", refMsg);
100
101 assert_checkfalse(execstr("eigs(A,[1 2])", "errcatch") == 0);
102 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
103 assert_checkerror("eigs(A,[1 2])", refMsg);
104
105 assert_checkfalse(execstr("eigs(A,[1;2])", "errcatch") == 0);
106 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
107 assert_checkerror("eigs(A,[1;2])", refMsg);
108
109 assert_checkfalse(execstr("eigs(sparse(A), [1 2])", "errcatch") == 0);
110 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
111 assert_checkerror("eigs(sparse(A), [1 2])", refMsg);
112
113 assert_checkfalse(execstr("eigs(sparse(A), [1;2])", "errcatch") == 0);
114 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
115 assert_checkerror("eigs(sparse(A), [1;2])", refMsg);
116
117
118 assert_checkfalse(execstr("eigs(A, [], [])", "errcatch") == 0);
119 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
120 assert_checkerror("eigs(A, [], [])", refMsg);
121
122 assert_checkfalse(execstr("eigs(A, [], %f)", "errcatch") == 0);
123 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
124 assert_checkerror("eigs(A, [], %f)", refMsg);
125
126 assert_checkfalse(execstr("eigs(A, [], 2*%i)", "errcatch") == 0);
127 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
128 assert_checkerror("eigs(A, [], 2*%i)", refMsg);
129
130 assert_checkfalse(execstr("eigs(A, [], -15)", "errcatch") == 0);
131 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
132 assert_checkerror("eigs(A, [], -15)", refMsg);
133
134 assert_checkfalse(execstr("eigs(A, [], 5.6)", "errcatch") == 0);
135 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
136 assert_checkerror("eigs(A, [], 5.6)", refMsg);
137
138 assert_checkfalse(execstr("eigs(A, [], [1 2])", "errcatch") == 0);
139 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
140 assert_checkerror("eigs(A, [], [1 2])", refMsg);
141
142 assert_checkfalse(execstr("eigs(A, [], %nan)", "errcatch") == 0);
143 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
144 assert_checkerror("eigs(A, [], %nan)", refMsg);
145
146 assert_checkfalse(execstr("eigs(A, [], %eps)", "errcatch") == 0);
147 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
148 assert_checkerror("eigs(A, [], %eps)", refMsg);
149
150 assert_checkfalse(execstr("eigs(A, [], %inf)", "errcatch") == 0);
151 refMsg = msprintf(_("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
152 assert_checkerror("eigs(A, [], %inf)", refMsg);
153
154 assert_checkfalse(execstr("eigs(sparse(A), [], %f)", "errcatch") == 0);
155 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
156 assert_checkerror("eigs(sparse(A), [], %f)", refMsg);
157
158 assert_checkfalse(execstr("eigs(sparse(A), [], 2*%i)", "errcatch") == 0);
159 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
160 assert_checkerror("eigs(sparse(A), [], 2*%i)", refMsg);
161
162 assert_checkfalse(execstr("eigs(sparse(A), [], -15)", "errcatch") == 0);
163 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
164 assert_checkerror("eigs(sparse(A), [], -15)", refMsg);
165
166 assert_checkfalse(execstr("eigs(sparse(A), [], 5.6)", "errcatch") == 0);
167 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
168 assert_checkerror("eigs(sparse(A), [], 5.6)", refMsg);
169
170 assert_checkfalse(execstr("eigs(sparse(A), [], [1 2])", "errcatch") == 0);
171 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
172 assert_checkerror("eigs(sparse(A), [], [1 2])", refMsg);
173
174 assert_checkfalse(execstr("eigs(A, [], 4, [])", "errcatch") == 0);
175 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
176 assert_checkerror("eigs(A, [], 4, [])", refMsg);
177
178 assert_checkfalse(execstr("eigs(A, [], 4, %nan)", "errcatch") == 0);
179 refMsg = msprintf(_("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
180 assert_checkerror("eigs(A, [], 4, %nan)", refMsg);
181
182 assert_checkfalse(execstr("eigs(A, [], 4, %f)", "errcatch") == 0);
183 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
184 assert_checkerror("eigs(A, [], 4, %f)", refMsg);
185
186 assert_checkfalse(execstr("eigs(sparse(A), [], 4, [])", "errcatch") == 0);
187 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
188 assert_checkerror("eigs(sparse(A), [], 4, [])", refMsg);
189
190 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %nan)", "errcatch") == 0);
191 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
192 assert_checkerror("eigs(sparse(A), [], 4, %nan)", refMsg);
193
194 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %f)", "errcatch") == 0);
195 refMsg = msprintf(_("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 4);
196 assert_checkerror("eigs(sparse(A), [], 4, %f)", refMsg);
197
198 which = "ahh";
199 assert_checkfalse(execstr("eigs(A, [], 4, which)", "errcatch") == 0);
200 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
201 assert_checkerror("eigs(A, [], 4, which)", refMsg);
202
203 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which)", "errcatch") == 0);
204 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
205 assert_checkerror("eigs(sparse(A), [], 4, which)", refMsg);
206
207 which = "LM";
208 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
209 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
210 assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
211
212 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,%nan)", "errcatch") == 0);
213 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
214 assert_checkerror("eigs(sparse(A), [], 4, which, %nan)", refMsg);
215
216 opts.var = %nan;
217 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
218 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
219 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
220
221 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
222 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
223 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
224
225 clear opts
226 opts.maxiter  = [];
227 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
228 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
229 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
230
231 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
232 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
233 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
234
235 opts.maxiter  = %nan;
236 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
237 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
238 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
239
240 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
241 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
242 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
243
244 opts.maxiter  = %f;
245 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
246 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
247 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
248
249 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
250 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
251 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
252
253 opts.maxiter  = "ahh";
254 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
255 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
256 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
257
258 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
259 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
260 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
261
262 opts.maxiter = 5.1;
263 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
264 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
265 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
266
267 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
268 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
269 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
270
271 opts.maxiter = -5.1;
272 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
273 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
274 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
275
276 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
277 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
278 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
279
280 clear opts
281 opts.tol  = [];
282 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
283 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
284 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
285
286 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
287 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
288 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
289
290
291
292 opts.tol  = %nan;
293 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
294 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
295 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
296
297 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
298 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
299 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
300
301 opts.tol  = %f;
302 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
303 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
304 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
305
306 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
307 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
308 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
309
310 opts.tol  = "ahh";
311 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
312 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
313 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
314
315 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
316 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
317 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
318
319 clear opts
320 opts.ncv  = %nan;
321 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
322 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
323 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
324
325 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
326 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
327 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
328
329 opts.ncv  = %f;
330 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
331 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
332 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
333
334 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
335 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
336 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
337
338 opts.ncv  = "ahh";
339 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
340 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
341 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
342
343 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
344 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
345 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
346
347 opts.ncv  = %eps;
348 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
349 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
350 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
351
352 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
353 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
354 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
355
356 opts.ncv  = -5.1;
357 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
358 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
359 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
360
361 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
362 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
363 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
364
365 opts.ncv  = 5.1;
366 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
367 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
368 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
369
370 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
371 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
372 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
373
374 opts.ncv = n + 6;
375 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
376 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
377 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
378
379 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
380 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
381 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
382
383 clear opts
384 opts.cholB  = %nan;
385 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
386 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
387 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
388
389 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
390 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
391 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
392
393 opts.cholB  = "ahh";
394 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
395 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
396 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
397
398 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
399 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
400 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
401
402 opts.cholB  = %eps;
403 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
404 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
405 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
406
407 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
408 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
409 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
410
411 opts.cholB  = -5.1;
412 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
413 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
414 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
415
416 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
417 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
418 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
419
420 opts.cholB  = 5.1;
421 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
422 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
423 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
424
425 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
426 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
427 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
428
429
430
431 opts.cholB = [];
432 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
433 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
434 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
435
436 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
437 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
438 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
439
440 clear opts
441 opts.resid  = %nan;
442 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
443 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
444 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
445
446 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
447 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
448 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
449
450 opts.resid  = %f;
451 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
452 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
453 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
454
455 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
456 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
457 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
458
459 opts.resid  = "ahh";
460 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
461 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
462 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
463
464 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
465 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
466 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
467
468 opts.resid  = %eps;
469 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
470 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
471 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
472
473 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
474 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
475 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
476
477 opts.resid  = [1 2];
478 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
479 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
480 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
481
482 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
483 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
484 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
485
486 opts.resid  = [1;2];
487 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
488 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
489 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
490
491 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
492 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
493 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
494
495 opts.resid = [];
496 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
497 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
498 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
499
500 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
501 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
502 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
503
504 clear opts
505 opts.issym = %f;
506 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
507 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
508 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
509
510 clear opts
511 opts.isreal = %f;
512 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
513 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
514 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
515
516 clear opts
517 n = 20;
518 k = 5;
519 A            = diag(10*ones(n,1));
520 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
521 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
522 A = sparse(A);
523
524 d1 = eigs(A, [], k);
525 d0 = spec(full(A));
526 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
527
528 d1 = eigs(A, [], k, "LM");
529 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
530
531 d1 = eigs(A, [], k, "SM");
532 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
533
534 d1 = eigs(A, [], k, "LA");
535 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
536
537 d1 = eigs(A, [], k, "SA");
538 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
539
540 d1 = eigs(A, [], k, "BE");
541 assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
542
543 d1 = eigs(A, [], k, 2);
544 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
545
546 d1 = eigs(A, speye(n,n), k, "LM");
547 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
548
549 d1 = eigs(A, speye(n,n), k, 2);
550 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
551
552 opts.cholB = %t;
553 d1 = eigs(A, speye(n,n), k, "LM", opts);
554 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
555
556 opts.cholB = %t;
557 d1 = eigs(A, speye(n,n), k, 2, opts);
558 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
559
560 [d1, v1] = eigs(A, [], k, "LM");
561 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
562
563 [d1, v1] = eigs(A, [], k, "SM");
564 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
565
566 [d1, v1] = eigs(A, [], k, "LA");
567 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
568
569 [d1, v1] = eigs(A, [], k, "SA");
570 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
571
572 [d1, v1] = eigs(A, [], k, "BE");
573 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
574
575
576 n = 20;
577 k = 5;
578 A            = diag((1:n));
579 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
580 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
581 A = sparse(A);
582
583 d1 = eigs(A, [], k);
584 d0 = gsort(spec(full(A)));
585
586 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
587
588 d1 = eigs(A, [], k, "LM");
589 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
590
591 d1 = eigs(A, [], k, "SM");
592 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
593
594 d1 = eigs(A, [], k, "LR");
595 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
596
597 d1 = eigs(A, [], k, "SR");
598 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
599
600 d1 = eigs(A, [], k, "LI");
601 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
602
603 d1 = eigs(A, [], k, "SI");
604 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
605
606 d1 = eigs(A, [], k, 2);
607 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
608
609 d1 = eigs(A, speye(n,n), k, "LM");
610 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
611
612 d1 = eigs(A, speye(n,n), k, 2);
613 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
614
615 opts.cholB = %t;
616 d1 = eigs(A, speye(n,n), k, "LM", opts);
617 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
618
619 opts.cholB = %t;
620 d1 = eigs(A, speye(n,n), k, 2, opts);
621 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
622
623 [d1, v1] = eigs(A, [], k, "LM");
624 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
625
626 [d1, v1] = eigs(A, [], k, "SM");
627 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
628
629 [d1, v1] = eigs(A, [], k, "LR");
630 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
631
632 [d1, v1] = eigs(A, [], k, "SR");
633 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
634
635 [d1, v1] = eigs(A, [], k, "LI");
636 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
637
638 [d1, v1] = eigs(A, [], k, "SI");
639 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
640
641 n = 20;
642 k = 5;
643 A            = diag((1:n) + %i * ones(1,n));
644 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
645 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
646 A = sparse(A);
647
648 d1 = eigs(A, [], k);
649 d0 = gsort(spec(full(A)));
650 r = gsort(real(d0));
651 im = gsort(imag(d0));
652 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
653
654 d1 = eigs(A, [], k, "LM");
655 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
656
657 //d1 = eigs(A, [], k, 'SM');
658 //assert_checkalmostequal(abs(d1), abs(d0(1:k)), 1.e-14); // error -> impossible to invert complex sparse matrix
659
660 d1 = eigs(A, [], k, "LR");
661 assert_checkalmostequal(real(d1), real(d0(k:-1:1)), 1.e-10);
662
663 d1 = eigs(A, [], k, "SR");
664 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
665
666 d1 = eigs(A, [], k, "LI");
667 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
668
669 d1 = eigs(A, [], k, "SI");
670 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
671
672 d1 = eigs(A, speye(n,n), k, "LM");
673 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
674
675 opts.cholB = %t;
676 d1 = eigs(A, speye(n,n), k, "LM", opts);
677 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
678
679 [d1, v1] = eigs(A, [], k, "LM");
680 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
681
682 [d1, v1] = eigs(A, [], k, "LR");
683 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
684
685 [d1, v1] = eigs(A, [], k, "SR");
686 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
687
688 [d1, v1] = eigs(A, [], k, "LI");
689 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
690
691 [d1, v1] = eigs(A, [], k, "SI");
692 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
693
694
695 n = 20;
696 k = 5;
697 A            = diag(10*ones(n,1));
698 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
699 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
700
701 d1 = eigs(A, [], k);
702 d0 = spec(A);
703
704 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
705
706 d1 = eigs(A, [], k, "LM");
707 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
708
709 d1 = eigs(A, [], k, "SM");
710 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
711
712 d1 = eigs(A, [], k, "LA");
713 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
714
715 d1 = eigs(A, [], k, "SA");
716 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
717
718 d1 = eigs(A, [], k, "BE");
719 assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
720
721 d1 = eigs(A, [], k, 2);
722 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
723
724 d1 = eigs(A, eye(n,n), k, "LM");
725 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
726
727 d1 = eigs(A, eye(n,n), k, 2);
728 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
729
730 opts.cholB = %t;
731 d1 = eigs(A, eye(n,n), k, "LM", opts);
732 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
733
734 opts.cholB = %t;
735 d1 = eigs(A, eye(n,n), k, 2, opts);
736 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
737
738 [d1, v1] = eigs(A, [], k, "LM");
739 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
740
741 [d1, v1] = eigs(A, [], k, "SM");
742 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
743
744 [d1, v1] = eigs(A, [], k, "LA");
745 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
746
747 [d1, v1] = eigs(A, [], k, "SA");
748 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
749
750 [d1, v1] = eigs(A, [], k, "BE");
751 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
752
753 n = 20;
754 k = 5;
755 A            = diag((1:n));
756 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
757 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
758
759 d1 = eigs(A, [], k);
760 d0 = gsort(spec(A));
761
762 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
763
764 d1 = eigs(A, [], k, "LM");
765 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
766
767 d1 = eigs(A, [], k, "SM");
768 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
769
770 d1 = eigs(A, [], k, "LR");
771 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
772
773 d1 = eigs(A, [], k, "SR");
774 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
775
776 d1 = eigs(A, [], k, "LI");
777 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
778
779 d1 = eigs(A, [], k, "SI");
780 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
781
782 d1 = eigs(A, [], k, 2);
783 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
784
785 d1 = eigs(A, eye(n,n), k, "LM");
786 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
787
788 d1 = eigs(A, eye(n,n), k, 2);
789 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
790
791 opts.cholB = %t;
792 d1 = eigs(A, eye(n,n), k, "LM", opts);
793 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
794
795 opts.cholB = %t;
796 d1 = eigs(A, eye(n,n), k, 2, opts);
797 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
798
799 [d1, v1] = eigs(A, [], k, "LM");
800 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
801
802 [d1, v1] = eigs(A, [], k, "SM");
803 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
804
805 [d1, v1] = eigs(A, [], k, "LR");
806 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
807
808 [d1, v1] = eigs(A, [], k, "SR");
809 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
810
811 [d1, v1] = eigs(A, [], k, "LI");
812 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
813
814 [d1, v1] = eigs(A, [], k, "SI");
815 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
816
817
818 n = 20;
819 k = 5;
820 A            = diag((1:n) + %i * ones(1,n));
821 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
822 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
823
824 d1 = eigs(A, [], k);
825 d0 = gsort(spec(A));
826 r = gsort(real(d0));
827 im = gsort(imag(d0));
828
829 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
830
831 d1 = eigs(A, [], k, "LM");
832 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
833
834 d1 = eigs(A, [], k, "SM");
835 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
836
837 d1 = eigs(A, [], k, "LR");
838 assert_checkalmostequal(real(d1), r(k:-1:1), 1.e-10);
839
840 d1 = eigs(A, [], k, "SR");
841 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
842
843 d1 = eigs(A, [], k, "LI");
844 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
845
846 d1 = eigs(A, [], k, "SI");
847 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
848
849 d1 = eigs(A, [], k, 2);
850 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
851
852 d1 = eigs(A, eye(n,n), k, "LM");
853 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
854
855 opts.cholB = %t;
856 d1 = eigs(A, eye(n,n), k, "LM", opts);
857 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
858
859 opts.cholB = %t;
860 d1 = eigs(A, eye(n,n), k, 2, opts);
861 assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);
862
863 [d1, v1] = eigs(A, [], k, "LM");
864 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
865
866 [d1, v1] = eigs(A, [], k, "LR");
867 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
868
869 [d1, v1] = eigs(A, [], k, "SR");
870 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
871
872 [d1, v1] = eigs(A, [], k, "LI");
873 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
874
875 [d1, v1] = eigs(A, [], k, "SI");
876 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
877
878 clear opts
879 // Tests : A is a function
880 // Sparse matrix tests
881 n = 20;
882 k = 5;
883 A            = diag(10*ones(n,1));
884 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
885 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
886 A = sparse(A);
887
888 function y = fn(x)
889     y = A * x;
890 endfunction
891
892 opts.isreal = %t;
893 opts.issym = %t;
894
895 d1 = eigs(fn, n, [], k, "LM", opts );
896 d0 = spec(full(A));
897 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
898
899 clear fn
900 function y = fn(x)
901     y = A \x;
902 endfunction
903
904 opts.isreal = %t;
905 opts.issym = %t;
906
907 d1 = eigs(fn, n, [], k, "SM", opts );
908 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
909
910 clear fn
911 function y = fn(x)
912     y = (A - 2 * speye(n,n)) \x;
913 endfunction
914
915 opts.isreal = %t;
916 opts.issym = %t;
917
918 d1 = eigs(fn, n, [], k, 2, opts);
919 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
920
921 n = 20;
922 k = 5;
923 A            = diag((1:n));
924 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
925 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
926 A = sparse(A);
927
928 clear fn
929 function y = fn(x)
930     y = A * x;
931 endfunction
932
933 opts.isreal = %t;
934 opts.issym = %f;
935
936 d1 = eigs(fn, n, [], k, "LM", opts );
937 d0 = gsort(spec(full(A)));
938 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
939
940 clear fn
941 function y = fn(x)
942     y = A \x;
943 endfunction
944
945 opts.isreal = %t;
946 opts.issym = %f;
947
948 d1 = eigs(fn, n, [], k, "SM", opts );
949 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
950
951 clear fn
952 function y = fn(x)
953     y = (A - 2 * speye(n,n)) \x;
954 endfunction
955
956 opts.isreal = %t;
957 opts.issym = %f;
958
959 d1 = eigs(fn, n, [], k, 2, opts );
960 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
961
962
963 n = 20;
964 k = 5;
965 A            = diag((1:n) + %i * ones(1,n));
966 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
967 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
968 A = sparse(A);
969
970 clear fn
971 function y = fn(x)
972     y = A * x;
973 endfunction
974
975 opts.isreal = %f;
976 opts.issym = %f;
977
978 d1 = eigs(fn, n, [], k, "LM", opts );
979 d0 = gsort(spec(full(A)));
980 r = gsort(real(d0));
981 im = gsort(imag(d0));
982 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
983
984 clear fn
985 function y = fn(x)
986     y = A \x;
987 endfunction
988
989 opts.isreal = %f;
990 opts.issym = %f;
991
992 d1 = eigs(fn, n, [], k, "SM", opts );
993 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
994
995 clear fn
996 function y = fn(x)
997     y = (A - 2 * speye(n,n)) \x;
998 endfunction
999
1000 opts.isreal = %f;
1001 opts.issym = %f;
1002
1003 d1 = eigs(fn, n, [], k, 2, opts );
1004 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
1005
1006
1007
1008 clear opts
1009 // Full matrix tests
1010 n = 20;
1011 k = 5;
1012 A            = diag(10*ones(n,1));
1013 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1014 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
1015
1016 clear fn
1017 function y = fn(x)
1018     y = A * x;
1019 endfunction
1020
1021 opts.isreal = %t;
1022 opts.issym = %t;
1023
1024 d1 = eigs(fn, n, [], k, "LM", opts );
1025 d0 = spec(A);
1026 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
1027
1028 clear fn
1029 function y = fn(x)
1030     y = A \x;
1031 endfunction
1032
1033 opts.isreal = %t;
1034 opts.issym = %t;
1035
1036 d1 = eigs(fn, n, [], k, "SM", opts );
1037 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
1038
1039 clear fn
1040 function y = fn(x)
1041     y = (A - 2 * speye(n,n)) \x;
1042 endfunction
1043
1044 opts.isreal = %t;
1045 opts.issym = %t;
1046
1047 d1 = eigs(fn, n, [], k, 2, opts);
1048 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
1049
1050 n = 20;
1051 k = 5;
1052 A            = diag((1:n));
1053 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1054 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
1055
1056 clear fn
1057 function y = fn(x)
1058     y = A * x;
1059 endfunction
1060
1061 opts.isreal = %t;
1062 opts.issym = %f;
1063
1064 d1 = eigs(fn, n, [], k, "LM", opts );
1065 d0 = gsort(spec(A));
1066 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
1067
1068 clear fn
1069 function y = fn(x)
1070     y = A \x;
1071 endfunction
1072
1073 opts.isreal = %t;
1074 opts.issym = %f;
1075
1076 d1 = eigs(fn, n, [], k, "SM", opts );
1077 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
1078
1079 clear fn
1080 function y = fn(x)
1081     y = (A - 2 * speye(n,n)) \x;
1082 endfunction
1083
1084 opts.isreal = %t;
1085 opts.issym = %f;
1086
1087 d1 = eigs(fn, n, [], k, 2, opts );
1088 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
1089
1090
1091 n = 20;
1092 k = 5;
1093 A            = diag((1:n) + %i * ones(1,n));
1094 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1095 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
1096
1097 clear fn
1098 function y = fn(x)
1099     y = A * x;
1100 endfunction
1101
1102 opts.isreal = %f;
1103 opts.issym = %f;
1104
1105 d1 = eigs(fn, n, [], k, "LM", opts );
1106 d0 = gsort(spec(A));
1107 r = gsort(real(d0));
1108 im = gsort(imag(d0));
1109 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
1110
1111 clear fn
1112 function y = fn(x)
1113     y = A \x;
1114 endfunction
1115
1116 opts.isreal = %f;
1117 opts.issym = %f;
1118
1119 d1 = eigs(fn, n, [], k, "SM", opts );
1120 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
1121
1122 clear fn
1123 function y = fn(x)
1124     y = (A - 2 * speye(n,n)) \x;
1125 endfunction
1126
1127 opts.isreal = %f;
1128 opts.issym = %f;
1129
1130 d1 = eigs(fn, n, [], k, 2, opts );
1131 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);