After an arpack update, eigs test has been updated.
[scilab.git] / scilab / modules / arnoldi / tests / unit_tests / eigs.dia.ref
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 // <-- CLI SHELL MODE -->
8 // unit tests for eigs function
9 // =============================================================================
10 // Interface
11 // =========
12 assert_checkfalse(execstr("eigs()"   ,"errcatch") == 0);
13 refMsg = msprintf(_("%s : Wrong number of input arguments : %d to %d expected.\n"), "eigs", 1, 6);
14 assert_checkerror("eigs()", refMsg);
15 assert_checkfalse(execstr("eigs(1)","errcatch") == 0);
16 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
17 assert_checkerror("eigs(1)", refMsg);
18 assert_checkfalse(execstr("eigs([])", "errcatch") == 0);
19 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
20 assert_checkerror("eigs([])", refMsg);
21 assert_checkfalse(execstr("eigs(%nan)", "errcatch") == 0);
22 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
23 assert_checkerror("eigs(%nan)", refMsg);
24 assert_checkfalse(execstr("eigs(%inf)", "errcatch") == 0);
25 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
26 assert_checkerror("eigs(%inf)", refMsg);
27 assert_checkfalse(execstr("eigs(%eps)", "errcatch") == 0);
28 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
29 assert_checkerror("eigs(%eps)", refMsg);
30 assert_checkfalse(execstr("eigs([%f %f])", "errcatch") == 0);
31 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
32 assert_checkerror("eigs([%f %f])", refMsg);
33 assert_checkfalse(execstr("eigs(sparse([%f %f]))", "errcatch") == 0);
34 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
35 assert_checkerror("eigs(sparse([%f %f]))", refMsg);
36 assert_checkfalse(execstr("eigs([1 2])", "errcatch") == 0);
37 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
38 assert_checkerror("eigs([1 2])", refMsg);
39 assert_checkfalse(execstr("eigs([1; 2])", "errcatch") == 0);
40 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
41 assert_checkerror("eigs([1; 2])", refMsg);
42 assert_checkfalse(execstr("eigs(sparse([1 2]))", "errcatch") == 0);
43 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
44 assert_checkerror("eigs(sparse([1 2]))", refMsg);
45 assert_checkfalse(execstr("eigs(sparse([1; 2]))", "errcatch") == 0);
46 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
47 assert_checkerror("eigs(sparse([1; 2]))", refMsg);
48 n = 20;
49 A            = diag(10*ones(n,1));
50 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
51 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
52 assert_checkfalse(execstr("eigs(A, %f)", "errcatch") == 0);
53 refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
54 assert_checkerror("eigs(A, %f)", refMsg);
55 assert_checkfalse(execstr("eigs(A, %nan)", "errcatch") == 0);
56 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
57 assert_checkerror("eigs(A, %nan)", refMsg);
58 assert_checkfalse(execstr("eigs(A, %inf)", "errcatch") == 0);
59 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
60 assert_checkerror("eigs(A, %inf)", refMsg);
61 assert_checkfalse(execstr("eigs(A, %eps)", "errcatch") == 0);
62 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
63 assert_checkerror("eigs(A, %eps)", refMsg);
64 assert_checkfalse(execstr("eigs(sparse(A), %f)", "errcatch") == 0);
65 refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
66 assert_checkerror("eigs(sparse(A), %f)", refMsg);
67 assert_checkfalse(execstr("eigs(sparse(A), %nan)", "errcatch") == 0);
68 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
69 assert_checkerror("eigs(sparse(A), %nan)", refMsg);
70 assert_checkfalse(execstr("eigs(sparse(A), %inf)", "errcatch") == 0);
71 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
72 assert_checkerror("eigs(sparse(A), %inf)", refMsg);
73 assert_checkfalse(execstr("eigs(sparse(A), %eps)", "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(sparse(A), %eps)", refMsg);
76 assert_checkfalse(execstr("eigs(A,[1 2])", "errcatch") == 0);
77 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
78 assert_checkerror("eigs(A,[1 2])", refMsg);
79 assert_checkfalse(execstr("eigs(A,[1;2])", "errcatch") == 0);
80 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
81 assert_checkerror("eigs(A,[1;2])", refMsg);
82 assert_checkfalse(execstr("eigs(sparse(A), [1 2])", "errcatch") == 0);
83 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
84 assert_checkerror("eigs(sparse(A), [1 2])", refMsg);
85 assert_checkfalse(execstr("eigs(sparse(A), [1;2])", "errcatch") == 0);
86 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
87 assert_checkerror("eigs(sparse(A), [1;2])", refMsg);
88 assert_checkfalse(execstr("eigs(A, [], [])", "errcatch") == 0);
89 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
90 assert_checkerror("eigs(A, [], [])", refMsg);
91 assert_checkfalse(execstr("eigs(A, [], %f)", "errcatch") == 0);
92 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
93 assert_checkerror("eigs(A, [], %f)", refMsg);
94 assert_checkfalse(execstr("eigs(A, [], 2*%i)", "errcatch") == 0);
95 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
96 assert_checkerror("eigs(A, [], 2*%i)", refMsg);
97 assert_checkfalse(execstr("eigs(A, [], -15)", "errcatch") == 0);
98 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
99 assert_checkerror("eigs(A, [], -15)", refMsg);
100 assert_checkfalse(execstr("eigs(A, [], 5.6)", "errcatch") == 0);
101 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
102 assert_checkerror("eigs(A, [], 5.6)", refMsg);
103 assert_checkfalse(execstr("eigs(A, [], [1 2])", "errcatch") == 0);
104 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
105 assert_checkerror("eigs(A, [], [1 2])", refMsg);
106 assert_checkfalse(execstr("eigs(A, [], %nan)", "errcatch") == 0);
107 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
108 assert_checkerror("eigs(A, [], %nan)", refMsg);
109 assert_checkfalse(execstr("eigs(A, [], %eps)", "errcatch") == 0);
110 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
111 assert_checkerror("eigs(A, [], %eps)", refMsg);
112 assert_checkfalse(execstr("eigs(A, [], %inf)", "errcatch") == 0);
113 refMsg = msprintf(_("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
114 assert_checkerror("eigs(A, [], %inf)", refMsg);
115 assert_checkfalse(execstr("eigs(sparse(A), [], %f)", "errcatch") == 0);
116 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
117 assert_checkerror("eigs(sparse(A), [], %f)", refMsg);
118 assert_checkfalse(execstr("eigs(sparse(A), [], 2*%i)", "errcatch") == 0);
119 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
120 assert_checkerror("eigs(sparse(A), [], 2*%i)", refMsg);
121 assert_checkfalse(execstr("eigs(sparse(A), [], -15)", "errcatch") == 0);
122 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
123 assert_checkerror("eigs(sparse(A), [], -15)", refMsg);
124 assert_checkfalse(execstr("eigs(sparse(A), [], 5.6)", "errcatch") == 0);
125 refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
126 assert_checkerror("eigs(sparse(A), [], 5.6)", refMsg);
127 assert_checkfalse(execstr("eigs(sparse(A), [], [1 2])", "errcatch") == 0);
128 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
129 assert_checkerror("eigs(sparse(A), [], [1 2])", refMsg);
130 assert_checkfalse(execstr("eigs(A, [], 4, [])", "errcatch") == 0);
131 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
132 assert_checkerror("eigs(A, [], 4, [])", refMsg);
133 assert_checkfalse(execstr("eigs(A, [], 4, %nan)", "errcatch") == 0);
134 refMsg = msprintf(_("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
135 assert_checkerror("eigs(A, [], 4, %nan)", refMsg);
136 assert_checkfalse(execstr("eigs(A, [], 4, %f)", "errcatch") == 0);
137 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
138 assert_checkerror("eigs(A, [], 4, %f)", refMsg);
139 assert_checkfalse(execstr("eigs(sparse(A), [], 4, [])", "errcatch") == 0);
140 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
141 assert_checkerror("eigs(sparse(A), [], 4, [])", refMsg);
142 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %nan)", "errcatch") == 0);
143 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
144 assert_checkerror("eigs(sparse(A), [], 4, %nan)", refMsg);
145 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %f)", "errcatch") == 0);
146 refMsg = msprintf(_("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 4);
147 assert_checkerror("eigs(sparse(A), [], 4, %f)", refMsg);
148 which = "ahh";
149 assert_checkfalse(execstr("eigs(A, [], 4, which)", "errcatch") == 0);
150 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");
151 assert_checkerror("eigs(A, [], 4, which)", refMsg);
152 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which)", "errcatch") == 0);
153 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");
154 assert_checkerror("eigs(sparse(A), [], 4, which)", refMsg);
155 which = "LM";
156 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
157 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
158 assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
159 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,%nan)", "errcatch") == 0);
160 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
161 assert_checkerror("eigs(sparse(A), [], 4, which, %nan)", refMsg);
162 opts.var = %nan;
163 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
164 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
165 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
166 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
167 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
168 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
169 clear opts
170 opts.maxiter  = [];
171 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
172 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
173 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
174 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
175 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
176 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
177 opts.maxiter  = %nan;
178 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
179 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
180 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
181 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
182 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
183 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
184 opts.maxiter  = %f;
185 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
186 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
187 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
188 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
189 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
190 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
191 opts.maxiter  = "ahh";
192 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
193 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
194 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
195 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
196 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
197 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
198 opts.maxiter = 5.1;
199 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
200 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
201 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
202 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
203 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
204 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
205 opts.maxiter = -5.1;
206 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
207 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
208 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
209 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
210 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
211 assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
212 clear opts
213 opts.tol  = [];
214 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
215 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
216 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
217 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
218 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
219 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
220 opts.tol  = %nan;
221 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
222 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
223 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
224 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
225 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
226 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
227 opts.tol  = %f;
228 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
229 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
230 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
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 real scalar.\n"), "eigs", 6, "opts.tol");
233 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
234 opts.tol  = "ahh";
235 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
236 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
237 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
238 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
239 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
240 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
241 clear opts
242 opts.ncv  = %nan;
243 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
244 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
245 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
246 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
247 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
248 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
249 opts.ncv  = %f;
250 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
251 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
252 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
253 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
254 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
255 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
256 opts.ncv  = "ahh";
257 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
258 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
259 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
260 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
261 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
262 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
263 opts.ncv  = %eps;
264 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
265 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
266 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
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 scalar.\n"), "eigs", 7, "opts.ncv");
269 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
270 opts.ncv  = -5.1;
271 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
272 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
273 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
274 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
275 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
276 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
277 opts.ncv  = 5.1;
278 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
279 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
280 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
281 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
282 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
283 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
284 opts.ncv = n + 6;
285 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
286 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
287 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
288 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
289 refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
290 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
291 clear opts
292 opts.cholB  = %nan;
293 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
294 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
295 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
296 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
297 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
298 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
299 opts.cholB  = "ahh";
300 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
301 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
302 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
303 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
304 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
305 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
306 opts.cholB  = %eps;
307 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
308 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
309 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
310 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
311 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
312 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
313 opts.cholB  = -5.1;
314 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
315 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
316 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
317 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
318 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
319 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
320 opts.cholB  = 5.1;
321 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
322 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
323 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
324 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
325 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
326 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
327 opts.cholB = [];
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 or a boolean.\n"), "eigs", 8, "opts.cholB");
330 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
331 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
332 refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
333 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
334 clear opts
335 opts.resid  = %nan;
336 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
337 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
338 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
339 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
340 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
341 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
342 opts.resid  = %f;
343 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
344 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
345 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
346 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
347 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
348 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
349 opts.resid  = "ahh";
350 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
351 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
352 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
353 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
354 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
355 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
356 opts.resid  = %eps;
357 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
358 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
359 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
360 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
361 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
362 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
363 opts.resid  = [1 2];
364 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
365 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
366 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
367 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
368 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
369 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
370 opts.resid  = [1;2];
371 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
372 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
373 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
374 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
375 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
376 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
377 opts.resid = [];
378 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
379 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
380 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
381 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
382 refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
383 assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
384 clear opts
385 opts.issym = %f;
386 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
387 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
388 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
389 clear opts
390 opts.isreal = %f;
391 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
392 refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
393 assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
394 clear opts
395 n = 20;
396 k = 5;
397 A            = diag(10*ones(n,1));
398 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
399 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
400 A = sparse(A);
401 d1 = eigs(A, [], k);
402 d0 = spec(full(A));
403 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
404 d1 = eigs(A, [], k, "LM");
405 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
406 d1 = eigs(A, [], k, "SM");
407 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
408 d1 = eigs(A, [], k, "LA");
409 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
410 d1 = eigs(A, [], k, "SA");
411 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
412 d1 = eigs(A, [], k, "BE");
413 assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
414 d1 = eigs(A, [], k, 2);
415 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
416 d1 = eigs(A, speye(n,n), k, "LM");
417 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
418 d1 = eigs(A, speye(n,n), k, 2);
419 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
420 opts.cholB = %t;
421 d1 = eigs(A, speye(n,n), k, "LM", opts);
422 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
423 opts.cholB = %t;
424 d1 = eigs(A, speye(n,n), k, 2, opts);
425 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
426 [d1, v1] = eigs(A, [], k, "LM");
427 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
428 [d1, v1] = eigs(A, [], k, "SM");
429 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
430 [d1, v1] = eigs(A, [], k, "LA");
431 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
432 [d1, v1] = eigs(A, [], k, "SA");
433 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
434 [d1, v1] = eigs(A, [], k, "BE");
435 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
436 n = 20;
437 k = 5;
438 A            = diag((1:n));
439 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
440 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
441 A = sparse(A);
442 d1 = eigs(A, [], k);
443 d0 = gsort(spec(full(A)));
444 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
445 d1 = eigs(A, [], k, "LM");
446 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
447 d1 = eigs(A, [], k, "SM");
448 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
449 d1 = eigs(A, [], k, "LR");
450 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
451 d1 = eigs(A, [], k, "SR");
452 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
453 d1 = eigs(A, [], k, "LI");
454 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
455 d1 = eigs(A, [], k, "SI");
456 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
457 d1 = eigs(A, [], k, 2);
458 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
459 d1 = eigs(A, speye(n,n), k, "LM");
460 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
461 d1 = eigs(A, speye(n,n), k, 2);
462 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
463 opts.cholB = %t;
464 d1 = eigs(A, speye(n,n), k, "LM", opts);
465 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
466 opts.cholB = %t;
467 d1 = eigs(A, speye(n,n), k, 2, opts);
468 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
469 [d1, v1] = eigs(A, [], k, "LM");
470 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
471 [d1, v1] = eigs(A, [], k, "SM");
472 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
473 [d1, v1] = eigs(A, [], k, "LR");
474 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
475 [d1, v1] = eigs(A, [], k, "SR");
476 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
477 [d1, v1] = eigs(A, [], k, "LI");
478 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
479 [d1, v1] = eigs(A, [], k, "SI");
480 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
481 n = 20;
482 k = 5;
483 A            = diag((1:n) + %i * ones(1,n));
484 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
485 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
486 A = sparse(A);
487 d1 = eigs(A, [], k);
488 d0 = gsort(spec(full(A)));
489 r = gsort(real(d0));
490 im = gsort(imag(d0));
491 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
492 d1 = eigs(A, [], k, "LM");
493 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
494 //d1 = eigs(A, [], k, 'SM');
495 //assert_checkalmostequal(abs(d1), abs(d0(1:k)), 1.e-14); // error -> impossible to invert complex sparse matrix
496 d1 = eigs(A, [], k, "LR");
497 assert_checkalmostequal(real(d1), real(d0(k:-1:1)), 1.e-10);
498 d1 = eigs(A, [], k, "SR");
499 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
500 d1 = eigs(A, [], k, "LI");
501 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
502 d1 = eigs(A, [], k, "SI");
503 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
504 d1 = eigs(A, speye(n,n), k, "LM");
505 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
506 opts.cholB = %t;
507 d1 = eigs(A, speye(n,n), k, "LM", opts);
508 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
509 [d1, v1] = eigs(A, [], k, "LM");
510 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
511 [d1, v1] = eigs(A, [], k, "LR");
512 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
513 [d1, v1] = eigs(A, [], k, "SR");
514 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
515 [d1, v1] = eigs(A, [], k, "LI");
516 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
517 [d1, v1] = eigs(A, [], k, "SI");
518 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
519 n = 20;
520 k = 5;
521 A            = diag(10*ones(n,1));
522 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
523 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
524 d1 = eigs(A, [], k);
525 d0 = spec(A);
526 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
527 d1 = eigs(A, [], k, "LM");
528 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
529 d1 = eigs(A, [], k, "SM");
530 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
531 d1 = eigs(A, [], k, "LA");
532 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
533 d1 = eigs(A, [], k, "SA");
534 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
535 d1 = eigs(A, [], k, "BE");
536 assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
537 d1 = eigs(A, [], k, 2);
538 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
539 d1 = eigs(A, eye(n,n), k, "LM");
540 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
541 d1 = eigs(A, eye(n,n), k, 2);
542 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
543 opts.cholB = %t;
544 d1 = eigs(A, eye(n,n), k, "LM", opts);
545 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
546 opts.cholB = %t;
547 d1 = eigs(A, eye(n,n), k, 2, opts);
548 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
549 [d1, v1] = eigs(A, [], k, "LM");
550 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
551 [d1, v1] = eigs(A, [], k, "SM");
552 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
553 [d1, v1] = eigs(A, [], k, "LA");
554 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
555 [d1, v1] = eigs(A, [], k, "SA");
556 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
557 [d1, v1] = eigs(A, [], k, "BE");
558 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
559 n = 20;
560 k = 5;
561 A            = diag((1:n));
562 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
563 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
564 d1 = eigs(A, [], k);
565 d0 = gsort(spec(A));
566 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
567 d1 = eigs(A, [], k, "LM");
568 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
569 d1 = eigs(A, [], k, "SM");
570 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
571 d1 = eigs(A, [], k, "LR");
572 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
573 d1 = eigs(A, [], k, "SR");
574 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
575 d1 = eigs(A, [], k, "LI");
576 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
577 d1 = eigs(A, [], k, "SI");
578 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
579 d1 = eigs(A, [], k, 2);
580 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
581 d1 = eigs(A, eye(n,n), k, "LM");
582 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
583 d1 = eigs(A, eye(n,n), k, 2);
584 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
585 opts.cholB = %t;
586 d1 = eigs(A, eye(n,n), k, "LM", opts);
587 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
588 opts.cholB = %t;
589 d1 = eigs(A, eye(n,n), k, 2, opts);
590 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
591 [d1, v1] = eigs(A, [], k, "LM");
592 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
593 [d1, v1] = eigs(A, [], k, "SM");
594 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
595 [d1, v1] = eigs(A, [], k, "LR");
596 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
597 [d1, v1] = eigs(A, [], k, "SR");
598 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
599 [d1, v1] = eigs(A, [], k, "LI");
600 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
601 [d1, v1] = eigs(A, [], k, "SI");
602 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
603 n = 20;
604 k = 5;
605 A            = diag((1:n) + %i * ones(1,n));
606 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
607 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
608 d1 = eigs(A, [], k);
609 d0 = gsort(spec(A));
610 r = gsort(real(d0));
611 im = gsort(imag(d0));
612 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
613 d1 = eigs(A, [], k, "LM");
614 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
615 d1 = eigs(A, [], k, "SM");
616 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
617 d1 = eigs(A, [], k, "LR");
618 assert_checkalmostequal(real(d1), r(k:-1:1), 1.e-10);
619 d1 = eigs(A, [], k, "SR");
620 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
621 d1 = eigs(A, [], k, "LI");
622 assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
623 d1 = eigs(A, [], k, "SI");
624 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
625 d1 = eigs(A, [], k, 2);
626 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
627 d1 = eigs(A, eye(n,n), k, "LM");
628 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
629 opts.cholB = %t;
630 d1 = eigs(A, eye(n,n), k, "LM", opts);
631 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
632 opts.cholB = %t;
633 d1 = eigs(A, eye(n,n), k, 2, opts);
634 assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);
635 [d1, v1] = eigs(A, [], k, "LM");
636 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
637 [d1, v1] = eigs(A, [], k, "LR");
638 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
639 [d1, v1] = eigs(A, [], k, "SR");
640 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
641 [d1, v1] = eigs(A, [], k, "LI");
642 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
643 [d1, v1] = eigs(A, [], k, "SI");
644 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
645 clear opts
646 // Tests : A is a function
647 // Sparse matrix tests
648 n = 20;
649 k = 5;
650 A            = diag(10*ones(n,1));
651 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
652 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
653 A = sparse(A);
654 function y = fn(x)
655     y = A * x;
656 endfunction
657 opts.isreal = %t;
658 opts.issym = %t;
659 d1 = eigs(fn, n, [], k, "LM", opts );
660 d0 = spec(full(A));
661 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
662 clear fn
663 function y = fn(x)
664     y = A \x;
665 endfunction
666 opts.isreal = %t;
667 opts.issym = %t;
668 d1 = eigs(fn, n, [], k, "SM", opts );
669 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
670 clear fn
671 function y = fn(x)
672     y = (A - 2 * speye(n,n)) \x;
673 endfunction
674 opts.isreal = %t;
675 opts.issym = %t;
676 d1 = eigs(fn, n, [], k, 2, opts);
677 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
678 n = 20;
679 k = 5;
680 A            = diag((1:n));
681 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
682 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
683 A = sparse(A);
684 clear fn
685 function y = fn(x)
686     y = A * x;
687 endfunction
688 opts.isreal = %t;
689 opts.issym = %f;
690 d1 = eigs(fn, n, [], k, "LM", opts );
691 d0 = gsort(spec(full(A)));
692 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
693 clear fn
694 function y = fn(x)
695     y = A \x;
696 endfunction
697 opts.isreal = %t;
698 opts.issym = %f;
699 d1 = eigs(fn, n, [], k, "SM", opts );
700 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
701 clear fn
702 function y = fn(x)
703     y = (A - 2 * speye(n,n)) \x;
704 endfunction
705 opts.isreal = %t;
706 opts.issym = %f;
707 d1 = eigs(fn, n, [], k, 2, opts );
708 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
709 n = 20;
710 k = 5;
711 A            = diag((1:n) + %i * ones(1,n));
712 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
713 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
714 A = sparse(A);
715 clear fn
716 function y = fn(x)
717     y = A * x;
718 endfunction
719 opts.isreal = %f;
720 opts.issym = %f;
721 d1 = eigs(fn, n, [], k, "LM", opts );
722 d0 = gsort(spec(full(A)));
723 r = gsort(real(d0));
724 im = gsort(imag(d0));
725 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
726 clear fn
727 function y = fn(x)
728     y = A \x;
729 endfunction
730 opts.isreal = %f;
731 opts.issym = %f;
732 d1 = eigs(fn, n, [], k, "SM", opts );
733 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
734 clear fn
735 function y = fn(x)
736     y = (A - 2 * speye(n,n)) \x;
737 endfunction
738 opts.isreal = %f;
739 opts.issym = %f;
740 d1 = eigs(fn, n, [], k, 2, opts );
741 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
742 clear opts
743 // Full matrix tests
744 n = 20;
745 k = 5;
746 A            = diag(10*ones(n,1));
747 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
748 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
749 clear fn
750 function y = fn(x)
751     y = A * x;
752 endfunction
753 opts.isreal = %t;
754 opts.issym = %t;
755 d1 = eigs(fn, n, [], k, "LM", opts );
756 d0 = spec(A);
757 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
758 clear fn
759 function y = fn(x)
760     y = A \x;
761 endfunction
762 opts.isreal = %t;
763 opts.issym = %t;
764 d1 = eigs(fn, n, [], k, "SM", opts );
765 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
766 clear fn
767 function y = fn(x)
768     y = (A - 2 * speye(n,n)) \x;
769 endfunction
770 opts.isreal = %t;
771 opts.issym = %t;
772 d1 = eigs(fn, n, [], k, 2, opts);
773 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
774 n = 20;
775 k = 5;
776 A            = diag((1:n));
777 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
778 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
779 clear fn
780 function y = fn(x)
781     y = A * x;
782 endfunction
783 opts.isreal = %t;
784 opts.issym = %f;
785 d1 = eigs(fn, n, [], k, "LM", opts );
786 d0 = gsort(spec(A));
787 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
788 clear fn
789 function y = fn(x)
790     y = A \x;
791 endfunction
792 opts.isreal = %t;
793 opts.issym = %f;
794 d1 = eigs(fn, n, [], k, "SM", opts );
795 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
796 clear fn
797 function y = fn(x)
798     y = (A - 2 * speye(n,n)) \x;
799 endfunction
800 opts.isreal = %t;
801 opts.issym = %f;
802 d1 = eigs(fn, n, [], k, 2, opts );
803 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
804 n = 20;
805 k = 5;
806 A            = diag((1:n) + %i * ones(1,n));
807 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
808 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
809 clear fn
810 function y = fn(x)
811     y = A * x;
812 endfunction
813 opts.isreal = %f;
814 opts.issym = %f;
815 d1 = eigs(fn, n, [], k, "LM", opts );
816 d0 = gsort(spec(A));
817 r = gsort(real(d0));
818 im = gsort(imag(d0));
819 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
820 clear fn
821 function y = fn(x)
822     y = A \x;
823 endfunction
824 opts.isreal = %f;
825 opts.issym = %f;
826 d1 = eigs(fn, n, [], k, "SM", opts );
827 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
828 clear fn
829 function y = fn(x)
830     y = (A - 2 * speye(n,n)) \x;
831 endfunction
832 opts.isreal = %f;
833 opts.issym = %f;
834 d1 = eigs(fn, n, [], k, 2, opts );
835 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);