87e49baa2a3495394c8f59c4021891be6fa415fc
[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 opts.tol  = %nan;
291 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
292 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
293 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
294
295 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
296 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
297 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
298
299 opts.tol  = %f;
300 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
301 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
302 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
303
304 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
305 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
306 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
307
308 opts.tol  = "ahh";
309 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
310 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
311 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
312
313 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
314 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
315 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
316
317 clear opts
318 opts.ncv  = %nan;
319 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
320 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
321 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
322
323 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
324 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
325 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
326
327 opts.ncv  = %f;
328 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
329 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
330 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
331
332 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
333 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
334 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
335
336 opts.ncv  = "ahh";
337 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
338 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
339 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
340
341 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
342 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
343 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
344
345 opts.ncv  = %eps;
346 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
347 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
348 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
349
350 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
351 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
352 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
353
354 opts.ncv  = -5.1;
355 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
356 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
357 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
358
359 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
360 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
361 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
362
363 opts.ncv  = 5.1;
364 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
365 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
366 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
367
368 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
369 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
370 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
371
372 opts.ncv = n + 6;
373 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
374 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
375 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
376
377 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
378 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
379 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
380
381 clear opts
382 opts.cholB  = %nan;
383 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
384 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
385 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
386
387 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
388 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
389 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
390
391 opts.cholB  = "ahh";
392 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
393 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
394 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
395
396 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
397 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
398 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
399
400 opts.cholB  = %eps;
401 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
402 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
403 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
404
405 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
406 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
407 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
408
409 opts.cholB  = -5.1;
410 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
411 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
412 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
413
414 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
415 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
416 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
417
418 opts.cholB  = 5.1;
419 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
420 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
421 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
422
423 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
424 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
425 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
426
427
428
429 opts.cholB = [];
430 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
431 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
432 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
433
434 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
435 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
436 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
437
438 clear opts
439 opts.resid  = %nan;
440 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
441 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
442 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
443
444 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
445 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
446 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
447
448 opts.resid  = %f;
449 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
450 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
451 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
452
453 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
454 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
455 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
456
457 opts.resid  = "ahh";
458 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
459 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
460 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
461
462 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
463 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
464 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
465
466 opts.resid  = %eps;
467 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
468 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
469 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
470
471 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
472 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
473 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
474
475 opts.resid  = [1 2];
476 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
477 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
478 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
479
480 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
481 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
482 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
483
484 opts.resid  = [1;2];
485 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
486 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
487 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
488
489 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
490 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
491 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
492
493 opts.resid = [];
494 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
495 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
496 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
497
498 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
499 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
500 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
501
502 clear opts
503 opts.issym = %f;
504 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
505 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
506 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
507
508 clear opts
509 opts.isreal = %f;
510 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
511 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
512 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
513
514 clear opts
515 n = 20;
516 k = 5;
517 A            = diag(10*ones(n,1));
518 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
519 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
520 A = sparse(A);
521
522 d1 = eigs(A, [], k);
523 d0 = spec(full(A));
524 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
525
526 d1 = eigs(A, [], k, 'LM');
527 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
528
529 d1 = eigs(A, [], k, 'SM');
530 assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
531
532 d1 = eigs(A, [], k, 'LA');
533 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
534
535 d1 = eigs(A, [], k, 'SA');
536 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
537
538 d1 = eigs(A, [], k, 'BE');
539 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
540
541 d1 = eigs(A, [], k, 2); 
542 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
543
544 d1 = eigs(A, speye(n,n), k, 'LM');
545 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
546
547 d1 = eigs(A, speye(n,n), k, 2);
548 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
549
550 opts.cholB = %t;
551 d1 = eigs(A, speye(n,n), k, 'LM', opts); 
552 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
553
554 opts.cholB = %t;
555 d1 = eigs(A, speye(n,n), k, 2, opts); 
556 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
557
558 [d1, v1] = eigs(A, [], k, 'LM');
559 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
560
561 [d1, v1] = eigs(A, [], k, 'SM');
562 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
563
564 [d1, v1] = eigs(A, [], k, 'LA');
565 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
566
567 [d1, v1] = eigs(A, [], k, 'SA');
568 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
569
570 [d1, v1] = eigs(A, [], k, 'BE');
571 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
572
573
574 n = 20;
575 k = 5;
576 A            = diag((1:n));
577 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
578 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
579 A = sparse(A);
580
581 d1 = eigs(A, [], k);
582 d0 = gsort(spec(full(A)));
583
584 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
585
586 d1 = eigs(A, [], k, 'LM');
587 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
588
589 d1 = eigs(A, [], k, 'SM');
590 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
591
592 d1 = eigs(A, [], k, 'LR');
593 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
594
595 d1 = eigs(A, [], k, 'SR');
596 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
597
598 d1 = eigs(A, [], k, 'LI');
599 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
600
601 d1 = eigs(A, [], k, 'SI');
602 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
603
604 d1 = eigs(A, [], k, 2); 
605 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
606
607 d1 = eigs(A, speye(n,n), k, 'LM');
608 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
609
610 d1 = eigs(A, speye(n,n), k, 2);
611 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
612
613 opts.cholB = %t;
614 d1 = eigs(A, speye(n,n), k, 'LM', opts);
615 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
616
617 opts.cholB = %t;
618 d1 = eigs(A, speye(n,n), k, 2, opts);
619 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
620
621 [d1, v1] = eigs(A, [], k, 'LM');
622 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
623
624 [d1, v1] = eigs(A, [], k, 'SM');
625 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
626
627 [d1, v1] = eigs(A, [], k, 'LR');
628 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
629
630 [d1, v1] = eigs(A, [], k, 'SR');
631 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
632
633 [d1, v1] = eigs(A, [], k, 'LI');
634 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
635
636 [d1, v1] = eigs(A, [], k, 'SI');
637 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
638
639 n = 20;
640 k = 5;
641 A            = diag((1:n) + %i * ones(1,n));
642 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
643 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
644 A = sparse(A);
645
646 d1 = eigs(A, [], k);
647 d0 = gsort(spec(full(A)));
648 r = gsort(real(d0));
649 im = gsort(imag(d0));
650 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
651
652 d1 = eigs(A, [], k, 'LM');
653 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
654
655 //d1 = eigs(A, [], k, 'SM');
656 //assert_checkalmostequal(abs(d1), abs(d0(1:k)), 1.e-14); // error -> impossible to invert complex sparse matrix
657
658 d1 = eigs(A, [], k, 'LR');
659 assert_checkalmostequal(real(d1), real(d0(k:-1:1)), 1.e-10);
660
661 d1 = eigs(A, [], k, 'SR');
662 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
663
664 d1 = eigs(A, [], k, 'LI');
665 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
666
667 d1 = eigs(A, [], k, 'SI');
668 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10); 
669
670 d1 = eigs(A, speye(n,n), k, 'LM');
671 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
672
673 opts.cholB = %t;
674 d1 = eigs(A, speye(n,n), k, 'LM', opts);
675 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
676
677 [d1, v1] = eigs(A, [], k, 'LM');
678 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
679
680 [d1, v1] = eigs(A, [], k, 'LR');
681 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
682
683 [d1, v1] = eigs(A, [], k, 'SR');
684 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
685
686 [d1, v1] = eigs(A, [], k, 'LI');
687 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
688
689 [d1, v1] = eigs(A, [], k, 'SI');
690 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
691
692
693 n = 20;
694 k = 5;
695 A            = diag(10*ones(n,1));
696 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
697 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
698
699 d1 = eigs(A, [], k);
700 d0 = spec(A);
701
702 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
703
704 d1 = eigs(A, [], k, 'LM');
705 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
706
707 d1 = eigs(A, [], k, 'SM');
708 assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
709
710 d1 = eigs(A, [], k, 'LA');
711 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
712
713 d1 = eigs(A, [], k, 'SA');
714 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
715
716 d1 = eigs(A, [], k, 'BE');
717 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
718
719 d1 = eigs(A, [], k, 2); 
720 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
721
722 d1 = eigs(A, eye(n,n), k, 'LM');
723 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
724
725 d1 = eigs(A, eye(n,n), k, 2);
726 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
727
728 opts.cholB = %t;
729 d1 = eigs(A, eye(n,n), k, 'LM', opts); 
730 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
731
732 opts.cholB = %t;
733 d1 = eigs(A, eye(n,n), k, 2, opts); 
734 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
735
736 [d1, v1] = eigs(A, [], k, 'LM');
737 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
738
739 [d1, v1] = eigs(A, [], k, 'SM');
740 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
741
742 [d1, v1] = eigs(A, [], k, 'LA');
743 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
744
745 [d1, v1] = eigs(A, [], k, 'SA');
746 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
747
748 [d1, v1] = eigs(A, [], k, 'BE');
749 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
750
751 n = 20;
752 k = 5;
753 A            = diag((1:n));
754 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
755 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
756
757 d1 = eigs(A, [], k);
758 d0 = gsort(spec(A));
759
760 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
761
762 d1 = eigs(A, [], k, 'LM');
763 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
764
765 d1 = eigs(A, [], k, 'SM');
766 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
767
768 d1 = eigs(A, [], k, 'LR');
769 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
770
771 d1 = eigs(A, [], k, 'SR');
772 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
773
774 d1 = eigs(A, [], k, 'LI');
775 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
776
777 d1 = eigs(A, [], k, 'SI');
778 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
779
780 d1 = eigs(A, [], k, 2); 
781 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
782
783 d1 = eigs(A, eye(n,n), k, 'LM');
784 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
785
786 d1 = eigs(A, eye(n,n), k, 2);
787 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
788
789 opts.cholB = %t;
790 d1 = eigs(A, eye(n,n), k, 'LM', opts);
791 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
792
793 opts.cholB = %t;
794 d1 = eigs(A, eye(n,n), k, 2, opts);
795 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
796
797 [d1, v1] = eigs(A, [], k, 'LM');
798 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
799
800 [d1, v1] = eigs(A, [], k, 'SM');
801 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
802
803 [d1, v1] = eigs(A, [], k, 'LR');
804 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
805
806 [d1, v1] = eigs(A, [], k, 'SR');
807 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
808
809 [d1, v1] = eigs(A, [], k, 'LI');
810 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
811
812 [d1, v1] = eigs(A, [], k, 'SI');
813 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
814
815
816 n = 20;
817 k = 5;
818 A            = diag((1:n) + %i * ones(1,n));
819 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
820 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
821
822 d1 = eigs(A, [], k);
823 d0 = gsort(spec(A));
824 r = gsort(real(d0));
825 im = gsort(imag(d0));
826
827 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
828
829 d1 = eigs(A, [], k, 'LM');
830 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
831
832 d1 = eigs(A, [], k, 'SM');
833 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
834
835 d1 = eigs(A, [], k, 'LR');
836 assert_checkalmostequal(real(d1), r(k:-1:1), 1.e-10);
837
838 d1 = eigs(A, [], k, 'SR');
839 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);  
840
841 d1 = eigs(A, [], k, 'LI');
842 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
843
844 d1 = eigs(A, [], k, 'SI');
845 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
846
847 d1 = eigs(A, [], k, 2); 
848 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
849
850 d1 = eigs(A, eye(n,n), k, 'LM');
851 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
852
853 opts.cholB = %t;
854 d1 = eigs(A, eye(n,n), k, 'LM', opts);
855 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
856
857 opts.cholB = %t;
858 d1 = eigs(A, eye(n,n), k, 2, opts);
859 assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);  
860
861 [d1, v1] = eigs(A, [], k, 'LM');
862 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
863
864 [d1, v1] = eigs(A, [], k, 'LR');
865 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
866
867 [d1, v1] = eigs(A, [], k, 'SR');
868 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
869
870 [d1, v1] = eigs(A, [], k, 'LI');
871 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
872
873 [d1, v1] = eigs(A, [], k, 'SI');
874 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
875
876 clear opts
877 // Tests : A is a function
878 // Sparse matrix tests
879 n = 20;
880 k = 5;
881 A            = diag(10*ones(n,1));
882 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
883 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
884 A = sparse(A);
885
886 function y = fn(x)
887     y = A * x;
888 endfunction
889
890 opts.isreal = %t;
891 opts.issym = %t;
892
893 d1 = eigs(fn, n, [], k, 'LM', opts );
894 d0 = spec(full(A));
895 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
896
897 clear fn
898 function y = fn(x)
899     y = A \x;
900 endfunction
901
902 opts.isreal = %t;
903 opts.issym = %t;
904
905 d1 = eigs(fn, n, [], k, 'SM', opts );
906 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
907
908 clear fn
909 function y = fn(x)
910     y = (A - 2 * speye(n,n)) \x;
911 endfunction
912
913 opts.isreal = %t;
914 opts.issym = %t;
915
916 d1 = eigs(fn, n, [], k, 2, opts);
917 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
918
919 n = 20;
920 k = 5;
921 A            = diag((1:n));
922 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
923 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
924 A = sparse(A);
925
926 clear fn
927 function y = fn(x)
928     y = A * x;
929 endfunction
930
931 opts.isreal = %t;
932 opts.issym = %f;
933
934 d1 = eigs(fn, n, [], k, 'LM', opts );
935 d0 = gsort(spec(full(A)));
936 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
937
938 clear fn
939 function y = fn(x)
940     y = A \x;
941 endfunction
942
943 opts.isreal = %t;
944 opts.issym = %f;
945
946 d1 = eigs(fn, n, [], k, 'SM', opts );
947 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
948
949 clear fn
950 function y = fn(x)
951     y = (A - 2 * speye(n,n)) \x;
952 endfunction
953
954 opts.isreal = %t;
955 opts.issym = %f;
956
957 d1 = eigs(fn, n, [], k, 2, opts );
958 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
959
960
961 n = 20;
962 k = 5;
963 A            = diag((1:n) + %i * ones(1,n));
964 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
965 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
966 A = sparse(A);
967
968 clear fn
969 function y = fn(x)
970     y = A * x;
971 endfunction
972
973 opts.isreal = %f;
974 opts.issym = %f;
975
976 d1 = eigs(fn, n, [], k, 'LM', opts );
977 d0 = gsort(spec(full(A)));
978 r = gsort(real(d0));
979 im = gsort(imag(d0));
980 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
981
982 clear fn
983 function y = fn(x)
984     y = A \x;
985 endfunction
986
987 opts.isreal = %f;
988 opts.issym = %f;
989
990 d1 = eigs(fn, n, [], k, 'SM', opts );
991 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
992
993 clear fn
994 function y = fn(x)
995     y = (A - 2 * speye(n,n)) \x;
996 endfunction
997
998 opts.isreal = %f;
999 opts.issym = %f;
1000
1001 d1 = eigs(fn, n, [], k, 2, opts );
1002 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
1003
1004
1005
1006 clear opts
1007 // Full matrix tests
1008 n = 20;
1009 k = 5;
1010 A            = diag(10*ones(n,1));
1011 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1012 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
1013
1014 clear fn
1015 function y = fn(x)
1016     y = A * x;
1017 endfunction
1018
1019 opts.isreal = %t;
1020 opts.issym = %t;
1021
1022 d1 = eigs(fn, n, [], k, 'LM', opts );
1023 d0 = spec(A);
1024 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
1025
1026 clear fn
1027 function y = fn(x)
1028     y = A \x;
1029 endfunction
1030
1031 opts.isreal = %t;
1032 opts.issym = %t;
1033
1034 d1 = eigs(fn, n, [], k, 'SM', opts );
1035 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
1036
1037 clear fn
1038 function y = fn(x)
1039     y = (A - 2 * speye(n,n)) \x;
1040 endfunction
1041
1042 opts.isreal = %t;
1043 opts.issym = %t;
1044
1045 d1 = eigs(fn, n, [], k, 2, opts);
1046 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
1047
1048 n = 20;
1049 k = 5;
1050 A            = diag((1:n));
1051 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1052 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
1053
1054 clear fn
1055 function y = fn(x)
1056     y = A * x;
1057 endfunction
1058
1059 opts.isreal = %t;
1060 opts.issym = %f;
1061
1062 d1 = eigs(fn, n, [], k, 'LM', opts );
1063 d0 = gsort(spec(A));
1064 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
1065
1066 clear fn
1067 function y = fn(x)
1068     y = A \x;
1069 endfunction
1070
1071 opts.isreal = %t;
1072 opts.issym = %f;
1073
1074 d1 = eigs(fn, n, [], k, 'SM', opts );
1075 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
1076
1077 clear fn
1078 function y = fn(x)
1079     y = (A - 2 * speye(n,n)) \x;
1080 endfunction
1081
1082 opts.isreal = %t;
1083 opts.issym = %f;
1084
1085 d1 = eigs(fn, n, [], k, 2, opts );
1086 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
1087
1088
1089 n = 20;
1090 k = 5;
1091 A            = diag((1:n) + %i * ones(1,n));
1092 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
1093 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
1094
1095 clear fn
1096 function y = fn(x)
1097     y = A * x;
1098 endfunction
1099
1100 opts.isreal = %f;
1101 opts.issym = %f;
1102
1103 d1 = eigs(fn, n, [], k, 'LM', opts );
1104 d0 = gsort(spec(A));
1105 r = gsort(real(d0));
1106 im = gsort(imag(d0));
1107 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
1108
1109 clear fn
1110 function y = fn(x)
1111     y = A \x;
1112 endfunction
1113
1114 opts.isreal = %f;
1115 opts.issym = %f;
1116
1117 d1 = eigs(fn, n, [], k, 'SM', opts );
1118 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
1119
1120 clear fn
1121 function y = fn(x)
1122     y = (A - 2 * speye(n,n)) \x;
1123 endfunction
1124
1125 opts.isreal = %f;
1126 opts.issym = %f;
1127
1128 d1 = eigs(fn, n, [], k, 2, opts );
1129 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);