|
5590
|
1 #!/bin/sh |
|
|
2 |
|
|
3 # Some tests are commented out because they are known to be broken! |
|
|
4 # Search for "# fails" |
|
|
5 |
|
|
6 # ./buildtest.sh preset |
|
|
7 # creates test_sparse.m with preset tests. |
|
|
8 # Use "test test_sparse" from octave to run the tests. |
|
|
9 # |
|
|
10 # ./buildtest.sh random |
|
|
11 # Creates test_sprandom.m with randomly generated matrices. |
|
|
12 |
|
|
13 # buildtest.sh generates tests for real and complex sparse matrices. |
|
|
14 # Also, we want to run both fixed tests with known outputs (quick tests) |
|
|
15 # and longer tests with unknown outputs (thorough tests). This requires |
|
|
16 # two sets of tests --- one which uses preset matrices and another which |
|
|
17 # uses randomly generated matrices. |
|
|
18 # |
|
|
19 # The tests are mostly identical for each case but the code is different, |
|
|
20 # so it is important that the tests be run on all cases. Because our test |
|
|
21 # harness doesn't have support for looping or macros (it is only needed |
|
|
22 # for new data types), but sh does, we use sh to generate inline versions of |
|
|
23 # the tests for each case. |
|
|
24 # |
|
|
25 # Our 'macros' use shared variables as parameters. This allows us to |
|
|
26 # for example define A complex and include all the unary ops tests, |
|
|
27 # then set A=real(A) and include all the unary ops tests. Thus the |
|
|
28 # same tests work for real and complex. For binary tests it is even |
|
|
29 # more complicated because we want full X sparse, sparse X full and |
|
|
30 # sparse X sparse tested. |
|
|
31 # |
|
|
32 # We use the following macros: |
|
|
33 # |
|
|
34 # gen_section |
|
|
35 # place a separator in the test file |
|
|
36 # gen_function |
|
|
37 # define the function definion |
|
|
38 # helper gen_specific |
|
|
39 # specific tests such as error handling and null input |
|
|
40 # helper gen_eat_zeros |
|
|
41 # make sure sparse-scalar ops which generate 0 work |
|
|
42 # gen_specific_tests |
|
|
43 # specific and eat zeros tests |
|
|
44 # helper gen_ordering_tests |
|
|
45 # ordered comparison operators for real valued tests |
|
|
46 # helper gen_sparsesparse_ordering_tests |
|
|
47 # ordered comparison operators for real valued sparse-sparse tests |
|
|
48 # helper gen_elementop_tests |
|
|
49 # element-wise matrix binary operators, including scalar-matrix ops. |
|
|
50 # horizontal/vertical concatenation are here as well. |
|
|
51 # helper gen_sparsesparse_elementop_tests |
|
|
52 # element-wise matrix binary operators, for sparse-sparse ops. |
|
|
53 # horizontal/vertical concatenation are here as well. |
|
|
54 # helper gen_divop_tests |
|
|
55 # left and right matrix division operators of rectangular matrices. |
|
|
56 # Needs QR solvers |
|
|
57 # helper gen_square_divop_tests |
|
|
58 # left and right matrix division operators of square matrices. |
|
|
59 # helper gen_matrixop_tests |
|
|
60 # rectangular matrix binary operators: * |
|
|
61 # helper gen_matrixdiag_tests |
|
|
62 # Tests extract of diag and creation of diagonal matrices using |
|
|
63 # diag and spdiags functions |
|
|
64 # helper gen_matrixreshape_tests |
|
|
65 # Test the reshape function on sparse matrices |
|
|
66 # helper print_mapper_test |
|
|
67 # sub-helper function of gen_mapper_tests to print individual tests |
|
|
68 # helper gen_mapper_tests |
|
|
69 # Tests all of the one argument mapper functions. There are a few |
|
|
70 # specific tests that abs, real and imag return real values. |
|
|
71 # helper gen_unaryop_tests |
|
|
72 # functions and operators which transform a single matrix |
|
|
73 # helper gen_save_tests |
|
|
74 # Tests the load/save functionality for ascii/binary and hdf5 formats |
|
|
75 # gen_scalar_tests |
|
|
76 # element ops for real and complex scalar and sparse |
|
|
77 # gen_rectangular_tests |
|
|
78 # unary, element, and matrix tests for a and full/sparse b |
|
|
79 # gen_square_tests |
|
|
80 # operations which require square matrices: lu, inv, \ |
|
|
81 # A square non-singular matrix is defined from the rectangular |
|
|
82 # inputs A and B. |
|
|
83 # gen_assembly_tests |
|
|
84 # test for sparse constructors with 'sum' vs. 'unique' |
|
|
85 # gen_select_tests |
|
|
86 # indexing tests |
|
|
87 # gen_solver_tests |
|
|
88 # Tests the solve function with triangular/banded, etc matrices |
|
|
89 |
|
|
90 case $1 in |
|
|
91 random) preset=false ;; |
|
|
92 preset) preset=true ;; |
|
|
93 '') preset=true ;; |
|
|
94 *) echo "buildtest.sh random|preset" && exit 1 ;; |
|
|
95 esac |
|
|
96 |
|
|
97 if $preset; then |
|
|
98 TESTS=test_sparse.m |
|
|
99 else |
|
|
100 TESTS=test_sprandom.m |
|
|
101 fi |
|
|
102 |
|
|
103 # create initial file |
|
|
104 cat >$TESTS <<EOF |
|
|
105 ## THIS IS AN AUTOMATICALLY GENERATED FILE --- DO NOT EDIT --- |
|
|
106 ## instead modify build_sparse_tests.sh to generate the tests that you want. |
|
|
107 EOF |
|
|
108 |
|
|
109 |
|
|
110 # define all functions |
|
|
111 |
|
|
112 |
|
|
113 # ======================================================= |
|
|
114 # Section separator |
|
|
115 |
|
|
116 gen_section() { |
|
|
117 cat >>$TESTS <<EOF |
|
|
118 |
|
|
119 # ============================================================== |
|
|
120 |
|
|
121 EOF |
|
|
122 } |
|
|
123 |
|
|
124 |
|
|
125 # ======================================================= |
|
|
126 # Specific preset tests |
|
|
127 |
|
|
128 # ======================================================= |
|
|
129 # If a sparse operation yields zeros, then those elements |
|
|
130 # of the returned sparse matrix should be eaten. |
|
|
131 gen_eat_zeros() { |
|
|
132 cat >>$TESTS <<EOF |
|
|
133 %% Make sure newly introduced zeros get eaten |
|
|
134 %!assert(nnz(sparse([bf,bf,1]).^realmax),1); |
|
|
135 %!assert(nnz(sparse([1,bf,bf]).^realmax),1); |
|
|
136 %!assert(nnz(sparse([bf,bf,bf]).^realmax),0); |
|
|
137 |
|
|
138 %!assert(nnz(sparse([bf;bf;1]).^realmax),1); |
|
|
139 %!assert(nnz(sparse([1;bf;bf]).^realmax),1); |
|
|
140 %!assert(nnz(sparse([0.5;bf;bf]).^realmax),0); |
|
|
141 |
|
|
142 %!assert(nnz(sparse([bf,bf,1])*realmin),1); |
|
|
143 %!assert(nnz(sparse([1,bf,bf])*realmin),1); |
|
|
144 %!assert(nnz(sparse([bf,bf,bf])*realmin),0); |
|
|
145 |
|
|
146 %!assert(nnz(sparse([bf;bf;1])*realmin),1); |
|
|
147 %!assert(nnz(sparse([1;bf;bf])*realmin),1); |
|
|
148 %!assert(nnz(sparse([bf;bf;bf])*realmin),0); |
|
|
149 |
|
|
150 EOF |
|
|
151 } |
|
|
152 |
|
|
153 gen_specific() { |
|
|
154 cat >>$TESTS <<EOF |
|
|
155 |
|
|
156 %!test # segfault test from edd@debian.org |
|
|
157 %! n = 510; |
|
|
158 %! sparse(kron((1:n)', ones(n,1)), kron(ones(n,1), (1:n)'), ones(n)); |
|
|
159 |
|
|
160 %% segfault tests from Fabian@isas-berlin.de |
|
|
161 %% Note that the last four do not fail, but rather give a warning |
|
|
162 %% of a singular matrix, which is consistent with the full matrix |
|
|
163 %% behaviour. They are therefore disabled.. |
|
|
164 %!assert(spinv(sparse([1,1;1,1+i])),sparse([1-1i,1i;1i,-1i]),10*eps); |
|
|
165 % !error spinv( sparse( [1,1;1,1] ) ); |
|
|
166 % !error spinv( sparse( [0,0;0,1] ) ); |
|
|
167 % !error spinv( sparse( [0,0;0,1+i] ) ); |
|
|
168 % !error spinv( sparse( [0,0;0,0] ) ); |
|
|
169 |
|
|
170 %% error handling in constructor |
|
|
171 %!error sparse(1,[2,3],[1,2,3]); |
|
|
172 %!error sparse([1,1],[1,1],[1,2],3,3,"bogus"); |
|
|
173 %!error sparse([1,3],[1,-4],[3,5],2,2); |
|
|
174 %!error sparse([1,3],[1,-4],[3,5i],2,2); |
|
|
175 %!error sparse(-1,-1,1); |
|
|
176 EOF |
|
|
177 } |
|
|
178 |
|
|
179 |
|
|
180 gen_specific_tests() { |
|
|
181 gen_section |
|
|
182 gen_specific |
|
|
183 gen_section |
|
|
184 echo '%!shared bf' >> $TESTS |
|
|
185 echo '%!test bf=realmin;' >> $TESTS |
|
|
186 gen_eat_zeros |
|
|
187 echo '%!test bf=realmin+realmin*1i;' >> $TESTS |
|
|
188 gen_eat_zeros |
|
|
189 cat >>$TESTS <<EOF |
|
|
190 %!assert(nnz(sparse([-1,realmin,realmin]).^1.5),1); |
|
|
191 %!assert(nnz(sparse([-1,realmin,realmin,1]).^1.5),2); |
|
|
192 |
|
|
193 %!assert(nnz(sparse(1,1,0)),0); # Make sure scalar v==0 doesn't confuse matters |
|
|
194 %!assert(nnz(sparse(eye(3))*0),0); |
|
|
195 %!assert(nnz(sparse(eye(3))-sparse(eye(3))),0); |
|
|
196 |
|
|
197 %!test |
|
5781
|
198 %! wdbz = warning ("query", "Octave:divide-by-zero"); |
|
|
199 %! warning ("off", "Octave:divide-by-zero"); |
|
5590
|
200 %! assert(sparse(eye(3))/0,sparse(eye(3)/0,1)); |
|
5781
|
201 %! warning (wdbz.state, "Octave:divide-by-zero"); |
|
5590
|
202 |
|
|
203 EOF |
|
|
204 } |
|
|
205 |
|
|
206 |
|
|
207 # ======================================================= |
|
|
208 # Main function definition |
|
|
209 |
|
|
210 gen_function() { |
|
|
211 if $preset; then |
|
|
212 cat >>$TESTS <<EOF |
|
|
213 ## |
|
|
214 ## test_sparse |
|
|
215 ## |
|
|
216 ## run preset sparse tests. All should pass. |
|
|
217 function [passes,tests] = test_sparse |
|
|
218 disp("writing test output to sptest.log"); |
|
|
219 test("test_sparse","normal","sptest.log"); |
|
|
220 endfunction |
|
|
221 |
|
|
222 EOF |
|
|
223 else |
|
|
224 cat >>$TESTS <<EOF |
|
|
225 ## |
|
|
226 ## test_sprandom |
|
|
227 ## |
|
|
228 ## total_passes=0; total_tests=0; |
|
|
229 ## for i=1:10 |
|
|
230 ## [passes,tests] = sprandomtest; |
|
|
231 ## total_passes += passes; |
|
|
232 ## total_tests += tests; |
|
|
233 ## end |
|
|
234 ## The test log is appended to sprandomtest.log |
|
|
235 function [passes,total] = test_sprandom |
|
|
236 warning("untested --- fix the source in buildtests.sh"); |
|
|
237 disp("appending test output to sprandomtest.log"); |
|
|
238 fid = fopen("sprandomtest.log","at"); |
|
|
239 test("test_sprandom","normal",fid); |
|
|
240 ##[passes, total] = test("sprandomtest","normal",fid); |
|
|
241 fclose(fid); |
|
|
242 endfunction |
|
|
243 |
|
|
244 EOF |
|
|
245 fi |
|
|
246 |
|
|
247 } |
|
|
248 |
|
|
249 |
|
|
250 # ======================================================= |
|
|
251 # matrix ops |
|
|
252 |
|
|
253 # test ordered comparisons: uses as,af,bs,bf |
|
|
254 gen_ordering_tests() { |
|
|
255 cat >>$TESTS <<EOF |
|
|
256 %% real values can be ordered (uses as,af) |
|
|
257 %!assert(as<=bf,sparse(af<=bf,true)) |
|
|
258 %!assert(bf<=as,sparse(bf<=af,true)) |
|
|
259 |
|
|
260 %!assert(as>=bf,sparse(af>=bf,true)) |
|
|
261 %!assert(bf>=as,sparse(bf>=af,true)) |
|
|
262 |
|
|
263 %!assert(as<bf,sparse(af<bf,true)) |
|
|
264 %!assert(bf<as,sparse(bf<af,true)) |
|
|
265 |
|
|
266 %!assert(as>bf,sparse(af>bf,true)) |
|
|
267 %!assert(bf>as,sparse(bf>af,true)) |
|
|
268 |
|
|
269 EOF |
|
|
270 } |
|
|
271 |
|
|
272 gen_sparsesparse_ordering_tests() { |
|
|
273 cat >>$TESTS <<EOF |
|
|
274 %!assert(as<=bs,sparse(af<=bf,true)) |
|
|
275 %!assert(as>=bs,sparse(af>=bf,true)) |
|
|
276 %!assert(as<bs,sparse(af<bf,true)) |
|
|
277 %!assert(as>bs,sparse(af>bf,true)) |
|
|
278 EOF |
|
|
279 } |
|
|
280 |
|
|
281 # test element-wise binary operations: uses as,af,bs,bf,scalar |
|
|
282 gen_elementop_tests() { |
|
|
283 cat >>$TESTS <<EOF |
|
|
284 %% Elementwise binary tests (uses as,af,bs,bf,scalar) |
|
|
285 %!assert(as==bs,sparse(af==bf,true)) |
|
|
286 %!assert(bf==as,sparse(bf==af,true)) |
|
|
287 |
|
|
288 %!assert(as!=bf,sparse(af!=bf,true)) |
|
|
289 %!assert(bf!=as,sparse(bf!=af,true)) |
|
|
290 |
|
|
291 %!assert(as+bf,af+bf) |
|
|
292 %!assert(bf+as,bf+af) |
|
|
293 |
|
|
294 %!assert(as-bf,af-bf) |
|
|
295 %!assert(bf-as,bf-af) |
|
|
296 |
|
|
297 %!assert(as.*bf,sparse(af.*bf,true)) |
|
|
298 %!assert(bf.*as,sparse(bf.*af,true)) |
|
|
299 |
|
|
300 %!assert(as./bf,sparse(af./bf,true),100*eps) |
|
|
301 %!assert(bf.\as,sparse(bf.\af,true),100*eps) |
|
|
302 |
|
|
303 %!test |
|
|
304 %! sv = as.^bf; |
|
|
305 %! fv = af.^bf; |
|
|
306 %! idx = find(af~=0); |
|
|
307 %! assert(sv(:)(idx),sparse(fv(:)(idx),true),100*eps) |
|
|
308 |
|
|
309 EOF |
|
|
310 } |
|
|
311 |
|
|
312 gen_sparsesparse_elementop_tests() { |
|
|
313 cat >>$TESTS <<EOF |
|
|
314 %!assert(as==bs,sparse(af==bf,true)) |
|
|
315 %!assert(as!=bs,sparse(af!=bf,true)) |
|
|
316 %!assert(as+bs,sparse(af+bf,true)) |
|
|
317 %!assert(as-bs,sparse(af-bf,true)) |
|
|
318 %!assert(as.*bs,sparse(af.*bf,true)) |
|
|
319 %!assert(as./bs,sparse(af./bf,true),100*eps); |
|
|
320 %!test |
|
|
321 %! sv = as.^bs; |
|
|
322 %! fv = af.^bf; |
|
|
323 %! idx = find(af~=0); |
|
|
324 %! assert(sv(:)(idx),sparse(fv(:)(idx),true),100*eps) |
|
|
325 |
|
|
326 EOF |
|
|
327 } |
|
|
328 |
|
|
329 # test matrix-matrix left and right division: uses as,af,bs,bf |
|
|
330 gen_divop_tests() { |
|
|
331 cat >>$TESTS <<EOF |
|
|
332 %% Matrix-matrix operators (uses af,as,bs,bf) |
|
|
333 %!assert(as/bf,af/bf,100*eps) |
|
|
334 %!assert(af/bs,af/bf,100*eps) |
|
|
335 %!assert(as/bs,sparse(af/bf,true),100*eps) |
|
|
336 %!assert(bs\af',bf\af',100*eps) |
|
|
337 %!assert(bf\as',bf\af',100*eps) |
|
|
338 %!assert(bs\as',sparse(bf\af',true),100*eps) |
|
|
339 |
|
|
340 EOF |
|
|
341 } |
|
|
342 |
|
|
343 # test matrix-matrix left and right division: uses as,af,bs,bf |
|
|
344 gen_square_divop_tests() { |
|
|
345 cat >>$TESTS <<EOF |
|
|
346 %% Matrix-matrix operators (uses af,as,bs,bf) |
|
|
347 %!assert(as/bf,af/bf,100*eps) |
|
|
348 %!assert(af/bs,af/bf,100*eps) |
|
|
349 %!assert(as/bs,sparse(af/bf,true),100*eps) |
|
|
350 %!assert(bs\af',bf\af',100*eps) |
|
|
351 %!assert(bf\as',bf\af',100*eps) |
|
|
352 %!assert(bs\as',sparse(bf\af',true),100*eps) |
|
|
353 |
|
|
354 EOF |
|
|
355 } |
|
|
356 |
|
|
357 # test matrix-matrix operations: uses as,af,bs,bf |
|
|
358 gen_matrixop_tests() { |
|
|
359 cat >>$TESTS <<EOF |
|
|
360 %% Matrix-matrix operators (uses af,as,bs,bf) |
|
|
361 %!assert(as*bf',af*bf') |
|
|
362 %!assert(af*bs',af*bf') |
|
|
363 %!assert(as*bs',sparse(af*bf',true)) |
|
|
364 |
|
|
365 EOF |
|
|
366 } |
|
|
367 |
|
|
368 # test diagonal operations |
|
|
369 gen_matrixdiag_tests() { |
|
|
370 cat >>$TESTS <<EOF |
|
|
371 %% Matrix diagonal tests (uses af,as,bf,bs) |
|
|
372 %!assert(spdiag(as),sparse(diag(af),true)) |
|
|
373 %!assert(spdiag(bs),sparse(diag(bf),true)) |
|
|
374 %!assert(spdiag(as,1),sparse(diag(af,1),true)) |
|
|
375 %!assert(spdiag(bs,1),sparse(diag(bf,1),true)) |
|
|
376 %!assert(spdiag(as,-1),sparse(diag(af,-1),true)) |
|
|
377 %!assert(spdiag(bs,-1),sparse(diag(bf,-1),true)) |
|
|
378 %!assert(spdiag(as(:)),sparse(diag(af(:)),true)) |
|
|
379 %!assert(spdiag(as(:),1),sparse(diag(af(:),1),true)) |
|
|
380 %!assert(spdiag(as(:),-1),sparse(diag(af(:),-1),true)) |
|
|
381 %!assert(spdiag(as(:)'),sparse(diag(af(:)'),true)) |
|
|
382 %!assert(spdiag(as(:)',1),sparse(diag(af(:)',1),true)) |
|
|
383 %!assert(spdiag(as(:)',-1),sparse(diag(af(:)',-1),true)) |
|
|
384 %!assert(spdiags(as,[0,1]),[diag(af,0),diag(af,1)]) |
|
|
385 %!test [tb,tc]=spdiags(as); |
|
|
386 %! assert(spdiags(tb,tc,sparse(zeros(size(as)))),as) |
|
|
387 %! assert(spdiags(tb,tc,size(as,1),size(as,2)),as) |
|
|
388 |
|
|
389 EOF |
|
|
390 } |
|
|
391 |
|
|
392 # test matrix reshape operations |
|
|
393 gen_matrixreshape_tests() { |
|
|
394 cat >>$TESTS <<EOF |
|
|
395 %% Matrix diagonal tests (uses af,as,bf,bs) |
|
|
396 %!assert(reshape(as,1,prod(size(as))),sparse(reshape(af,1,prod(size(af))),true)) |
|
|
397 %!assert(reshape(as,prod(size(as)),1),sparse(reshape(af,prod(size(af)),1),true)) |
|
|
398 %!assert(reshape(as,fliplr(size(as))),sparse(reshape(af,fliplr(size(af))),true)) |
|
|
399 %!assert(reshape(bs,1,prod(size(as))),sparse(reshape(bf,1,prod(size(af))),true)) |
|
|
400 %!assert(reshape(bs,prod(size(as)),1),sparse(reshape(bf,prod(size(af)),1),true)) |
|
|
401 %!assert(reshape(bs,fliplr(size(as))),sparse(reshape(bf,fliplr(size(af))),true)) |
|
|
402 |
|
|
403 EOF |
|
|
404 } |
|
|
405 |
|
|
406 # test mapper matrix operations: uses as,af |
|
|
407 print_mapper_test() { |
|
|
408 echo "%!assert($1(as),sparse($1(af),1))" >>$TESTS |
|
|
409 } |
|
|
410 |
|
|
411 print_real_mapper_test() { |
|
|
412 cat >>$TESTS <<EOF |
|
|
413 %!test |
|
5781
|
414 %! wn2s = warning ("query", "Octave:num-to-str"); |
|
|
415 %! warning ("off", "Octave:num-to-str"); |
|
5590
|
416 %! if isreal(af) |
|
5953
|
417 %! if ($2) |
|
|
418 %! assert($1(as),sparse($1(af),1)) |
|
|
419 %! else |
|
|
420 %! assert($1(as),$1(af)) |
|
|
421 %! endif |
|
5590
|
422 %! endif |
|
5781
|
423 %! warning (wn2s.state, "Octave:num-to-str"); |
|
5590
|
424 |
|
|
425 EOF |
|
|
426 } |
|
|
427 |
|
|
428 gen_mapper_tests() { |
|
|
429 echo "%% Unary matrix tests (uses af,as)">>$TESTS |
|
|
430 print_mapper_test abs |
|
|
431 print_mapper_test acos |
|
|
432 print_mapper_test acosh |
|
|
433 print_mapper_test angle |
|
|
434 print_mapper_test arg |
|
|
435 print_mapper_test asin |
|
|
436 print_mapper_test asinh |
|
|
437 print_mapper_test atan |
|
|
438 print_mapper_test atanh |
|
|
439 print_mapper_test ceil |
|
|
440 print_mapper_test conj |
|
|
441 print_mapper_test cos |
|
|
442 print_mapper_test cosh |
|
|
443 print_mapper_test exp |
|
|
444 print_mapper_test finite |
|
|
445 print_mapper_test fix |
|
|
446 print_mapper_test floor |
|
|
447 print_mapper_test imag |
|
|
448 print_mapper_test isinf |
|
|
449 print_mapper_test isna |
|
|
450 print_mapper_test isnan |
|
|
451 print_mapper_test log |
|
|
452 #print_mapper_test log10 ## fails with different NaN, not a problem |
|
|
453 print_mapper_test real |
|
|
454 print_mapper_test round |
|
|
455 print_mapper_test sign |
|
|
456 print_mapper_test sin |
|
|
457 print_mapper_test sinh |
|
|
458 print_mapper_test sqrt |
|
|
459 print_mapper_test tan |
|
|
460 print_mapper_test tanh |
|
|
461 |
|
|
462 # Specific tests for certain mapper functions |
|
|
463 cat >>$TESTS <<EOF |
|
|
464 %!assert(issparse(abs(as))&&isreal(abs(as))) |
|
|
465 %!assert(issparse(real(as))&&isreal(real(as))) |
|
|
466 %!assert(issparse(imag(as))&&isreal(imag(as))) |
|
|
467 |
|
|
468 EOF |
|
|
469 } |
|
|
470 |
|
|
471 gen_real_mapper_tests() { |
|
|
472 echo "%% Unary matrix tests (uses af,as)">>$TESTS |
|
5953
|
473 print_real_mapper_test erf 1 |
|
|
474 print_real_mapper_test erfc 1 |
|
|
475 #print_real_mapper_test gamma 1 |
|
|
476 print_real_mapper_test isalnum 0 |
|
|
477 print_real_mapper_test isalpha 0 |
|
|
478 print_real_mapper_test isascii 0 |
|
|
479 print_real_mapper_test iscntrl 0 |
|
|
480 print_real_mapper_test isdigit 0 |
|
|
481 print_real_mapper_test isgraph 0 |
|
|
482 print_real_mapper_test islower 0 |
|
|
483 print_real_mapper_test isprint 0 |
|
|
484 print_real_mapper_test ispunct 0 |
|
|
485 print_real_mapper_test isspace 0 |
|
|
486 print_real_mapper_test isupper 0 |
|
|
487 print_real_mapper_test isxdigit 0 |
|
|
488 #print_real_mapper_test lgamma 1 |
|
5590
|
489 |
|
|
490 # Specific tests for certain mapper functions |
|
|
491 cat >>$TESTS <<EOF |
|
|
492 |
|
|
493 %% These mapper functions always return a full matrix |
|
|
494 %!test |
|
5781
|
495 %! wn2s = warning ("query", "Octave:num-to-str"); |
|
|
496 %! warning ("off", "Octave:num-to-str"); |
|
5590
|
497 %! if isreal(af) |
|
|
498 %! assert(toascii(as),toascii(af)) |
|
|
499 %! assert(tolower(as),tolower(af)) |
|
|
500 %! assert(toupper(as),toupper(af)) |
|
|
501 %! endif |
|
5781
|
502 %! warning (wn2s.state, "Octave:num-to-str"); |
|
5590
|
503 |
|
|
504 EOF |
|
|
505 } |
|
|
506 |
|
|
507 # test matrix operations: uses as,af |
|
|
508 gen_unaryop_tests() { |
|
|
509 cat >>$TESTS <<EOF |
|
|
510 %% Unary matrix tests (uses af,as) |
|
|
511 %!assert(issparse(as)) |
|
|
512 %!assert(!issparse(af)) |
|
|
513 %!assert(!(issparse(af)&&iscomplex(af))) |
|
|
514 %!assert(!(issparse(af)&&isreal(af))) |
|
|
515 %!assert(spsum(as),sparse(sum(af),true)) |
|
|
516 %!assert(spsum(as,1),sparse(sum(af,1),true)) |
|
|
517 %!assert(spsum(as,2),sparse(sum(af,2),true)) |
|
|
518 %!assert(spcumsum(as),sparse(cumsum(af),true)) |
|
|
519 %!assert(spcumsum(as,1),sparse(cumsum(af,1),true)) |
|
|
520 %!assert(spcumsum(as,2),sparse(cumsum(af,2),true)) |
|
|
521 %!assert(spsumsq(as),sparse(sumsq(af),true)) |
|
|
522 %!assert(spsumsq(as,1),sparse(sumsq(af,1),true)) |
|
|
523 %!assert(spsumsq(as,2),sparse(sumsq(af,2),true)) |
|
|
524 %!assert(spprod(as),sparse(prod(af),true)) |
|
|
525 %!assert(spprod(as,1),sparse(prod(af,1),true)) |
|
|
526 %!assert(spprod(as,2),sparse(prod(af,2),true)) |
|
|
527 %!assert(spcumprod(as),sparse(cumprod(af),true)) |
|
|
528 %!assert(spcumprod(as,1),sparse(cumprod(af,1),true)) |
|
|
529 %!assert(spcumprod(as,2),sparse(cumprod(af,2),true)) |
|
|
530 |
|
|
531 %!assert(spmin(as),sparse(min(af),true)) |
|
|
532 %!assert(spmin(as(:)),min(af(:))) |
|
|
533 %!assert(spmin(as,[],1),sparse(min(af,[],1),true)) |
|
|
534 %!assert(spmin(as,[],2),sparse(min(af,[],2),true)) |
|
|
535 %!assert(spmin(as,[],1),sparse(min(af,[],1),true)) |
|
|
536 %!assert(spmin(as,0),sparse(min(af,0),true)) |
|
|
537 %!assert(spmin(as,bs),sparse(min(af,bf),true)) |
|
|
538 %!assert(spmax(as),sparse(max(af),true)) |
|
|
539 %!assert(spmax(as(:)),max(af(:))) |
|
|
540 %!assert(spmax(as,[],1),sparse(max(af,[],1),true)) |
|
|
541 %!assert(spmax(as,[],2),sparse(max(af,[],2),true)) |
|
|
542 %!assert(spmax(as,[],1),sparse(max(af,[],1),true)) |
|
|
543 %!assert(spmax(as,0),sparse(max(af,0),true)) |
|
|
544 %!assert(spmax(as,bs),sparse(max(af,bf),true)) |
|
|
545 |
|
|
546 %!assert(as==as) |
|
|
547 %!assert(as==af) |
|
|
548 %!assert(af==as) |
|
|
549 %!test |
|
|
550 %! [ii,jj,vv,nr,nc] = spfind(as); |
|
|
551 %! assert(af,full(sparse(ii,jj,vv,nr,nc))); |
|
|
552 %!assert(nnz(as),sum(af(:)!=0)) |
|
|
553 %!assert(nnz(as),nnz(af)) |
|
|
554 %!assert(issparse(as.')) |
|
|
555 %!assert(issparse(as')) |
|
|
556 %!assert(issparse(-as)) |
|
|
557 %!assert(~as,sparse(~af,true)) |
|
|
558 %!assert(as.', sparse(af.',true)); |
|
|
559 %!assert(as', sparse(af',true)); |
|
|
560 %!assert(-as, sparse(-af,true)); |
|
|
561 %!assert(~as, sparse(~af,true)); |
|
|
562 %!error [i,j]=size(af);as(i-1,j+1); |
|
|
563 %!error [i,j]=size(af);as(i+1,j-1); |
|
|
564 %!test |
|
|
565 %! [Is,Js,Vs] = spfind(as); |
|
|
566 %! [If,Jf,Vf] = find(af); |
|
|
567 %! assert(Is,If); |
|
|
568 %! assert(Js,Jf); |
|
|
569 %! assert(Vs,Vf); |
|
|
570 %!error as(0,1); |
|
|
571 %!error as(1,0); |
|
|
572 %!assert(spfind(as),find(af)) |
|
|
573 %!test |
|
|
574 %! [i,j,v] = spfind(as); |
|
|
575 %! [m,n] = size(as); |
|
|
576 %! x = sparse(i,j,v,m,n); |
|
|
577 %! assert(x,as); |
|
|
578 %!test |
|
|
579 %! [i,j,v,m,n] = spfind(as); |
|
|
580 %! x = sparse(i,j,v,m,n); |
|
|
581 %! assert(x,as); |
|
|
582 %!assert(issparse(horzcat(as,as))); |
|
|
583 %!assert(issparse(vertcat(as,as))); |
|
|
584 %!assert(issparse(cat(1,as,as))); |
|
|
585 %!assert(issparse(cat(2,as,as))); |
|
|
586 %!assert(issparse([as,as])); |
|
|
587 %!assert(issparse([as;as])); |
|
|
588 %!assert(horzcat(as,as), sparse([af,af])); |
|
|
589 %!assert(vertcat(as,as), sparse([af;af])); |
|
|
590 %!assert(horzcat(as,as,as), sparse([af,af,af])); |
|
|
591 %!assert(vertcat(as,as,as), sparse([af;af;af])); |
|
|
592 %!assert([as,as], sparse([af,af])); |
|
|
593 %!assert([as;as], sparse([af;af])); |
|
|
594 %!assert([as,as,as], sparse([af,af,af])); |
|
|
595 %!assert([as;as;as], sparse([af;af;af])); |
|
|
596 %!assert(cat(2,as,as), sparse([af,af])); |
|
|
597 %!assert(cat(1,as,as), sparse([af;af])); |
|
|
598 %!assert(cat(2,as,as,as), sparse([af,af,af])); |
|
|
599 %!assert(cat(1,as,as,as), sparse([af;af;af])); |
|
|
600 %!assert(issparse([as,af])); |
|
|
601 %!assert(issparse([af,as])); |
|
|
602 %!assert([as,af], sparse([af,af])); |
|
|
603 %!assert([as;af], sparse([af;af])); |
|
|
604 |
|
|
605 EOF |
|
|
606 } |
|
|
607 |
|
|
608 # operations which require square matrices. |
|
|
609 gen_square_tests() { |
|
|
610 # The \ and / operator tests on square matrices |
|
|
611 gen_square_divop_tests |
|
|
612 |
|
|
613 cat >>$TESTS <<EOF |
|
|
614 %!assert(spdet(bs+speye(size(bs))),det(bf+eye(size(bf))),100*eps*abs(det(bf+eye(size(bf))))) |
|
|
615 |
|
|
616 %!test |
|
|
617 %! [l,u]=splu(sparse([1,1;1,1])); |
|
|
618 %! assert(l*u,[1,1;1,1],10*eps); |
|
|
619 |
|
|
620 %!test |
|
|
621 %! [l,u]=splu(sparse([1,1;1,1+i])); |
|
|
622 %! assert(l,sparse([1,2,2],[1,1,2],1),10*eps); |
|
|
623 %! assert(u,sparse([1,1,2],[1,2,2],[1,1,1i]),10*eps); |
|
|
624 |
|
|
625 %!test ;# permuted LU |
|
|
626 %! [L,U] = splu(bs); |
|
|
627 %! assert(L*U,bs,1e-10); |
|
|
628 |
|
|
629 %!test ;# simple LU + row permutations |
|
|
630 %! [L,U,P] = splu(bs); |
|
|
631 %! assert(P'*L*U,bs,1e-10); |
|
|
632 %! # triangularity |
|
|
633 %! [i,j,v]=spfind(L); |
|
|
634 %! assert(i-j>=0); |
|
|
635 %! [i,j,v]=spfind(U); |
|
|
636 %! assert(j-i>=0); |
|
|
637 |
|
|
638 %!test ;# simple LU + row/col permutations |
|
|
639 %! [L,U,P,Q] = splu(bs); |
|
|
640 %! assert(P'*L*U*Q',bs,1e-10); |
|
|
641 %! # triangularity |
|
|
642 %! [i,j,v]=spfind(L); |
|
|
643 %! assert(i-j>=0); |
|
|
644 %! [i,j,v]=spfind(U); |
|
|
645 %! assert(j-i>=0); |
|
|
646 |
|
|
647 %!test ;# LU with fixed column permutation |
|
|
648 %! [L,U,P] = splu(bs,colamd(bs)); |
|
|
649 %! assert(P'*L*U,bs,1e-10); |
|
|
650 %! # triangularity |
|
|
651 %! [i,j,v]=spfind(L); |
|
|
652 %! assert(i-j>=0); |
|
|
653 %! [i,j,v]=spfind(U(:,colamd(bs))); |
|
|
654 %! assert(j-i>=0); |
|
|
655 |
|
|
656 %!test ;# LU with initial column permutation |
|
|
657 %! [L,U,P,Q] = splu(bs,colamd(bs)); |
|
|
658 %! assert(P'*L*U*Q',bs,1e-10); |
|
|
659 %! # triangularity |
|
|
660 %! [i,j,v]=spfind(L); |
|
|
661 %! assert(i-j>=0); |
|
|
662 %! [i,j,v]=spfind(U); |
|
|
663 %! assert(j-i>=0); |
|
|
664 |
|
|
665 %!test ;# inverse |
|
|
666 %! assert(spinv(bs)*bs,sparse(eye(rows(bs))),1e-10); |
|
|
667 |
|
|
668 %!assert(bf\as',bf\af',100*eps); |
|
|
669 %!assert(bs\af',bf\af',100*eps); |
|
|
670 %!assert(bs\as',sparse(bf\af'),100*eps); |
|
|
671 |
|
|
672 EOF |
|
|
673 } |
|
|
674 |
|
|
675 # Cholesky tests |
|
|
676 gen_cholesky_tests() { |
|
|
677 cat >>$TESTS <<EOF |
|
|
678 %!assert(spchol(bs)'*spchol(bs),bs,1e-10); |
|
|
679 %!assert(splchol(bs)*splchol(bs)',bs,1e-10); |
|
|
680 %!assert(splchol(bs),spchol(bs)',1e-10); |
|
|
681 |
|
|
682 %!test ;# Return Partial Cholesky factorization |
|
|
683 %! [RS,PS] = spchol(bs); |
|
|
684 %! assert(RS'*RS,bs,1e-10); |
|
|
685 %! assert(PS,0); |
|
|
686 %! [LS,PS] = splchol(bs); |
|
|
687 %! assert(LS*LS',bs,1e-10); |
|
|
688 %! assert(PS,0); |
|
|
689 |
|
|
690 %!test ;# Permuted Cholesky factorization |
|
|
691 %! [RS,PS,QS] = spchol(bs); |
|
|
692 %! assert(RS'*RS,QS*bs*QS',1e-10); |
|
|
693 %! assert(PS,0); |
|
|
694 %! [LS,PS,QS] = splchol(bs); |
|
|
695 %! assert(LS*LS',QS*bs*QS',1e-10); |
|
|
696 %! assert(PS,0); |
|
|
697 |
|
|
698 EOF |
|
|
699 } |
|
|
700 |
|
|
701 # test scalar operations: uses af and real scalar bf; modifies as,bf,bs |
|
|
702 gen_scalar_tests() { |
|
|
703 echo '%!test as=sparse(af);' >> $TESTS |
|
|
704 echo '%!test bs=bf;' >> $TESTS |
|
|
705 gen_elementop_tests |
|
|
706 gen_ordering_tests |
|
|
707 echo '%!test bf=bf+1i;' >>$TESTS |
|
|
708 echo '%!test bs=bf;' >> $TESTS |
|
|
709 gen_elementop_tests |
|
|
710 } |
|
|
711 |
|
|
712 # test matrix operations: uses af and bf; modifies as,bs |
|
|
713 gen_rectangular_tests() { |
|
|
714 echo '%!test as=sparse(af);' >> $TESTS |
|
|
715 echo '%!test bs=sparse(bf);' >>$TESTS |
|
|
716 gen_mapper_tests |
|
|
717 gen_real_mapper_tests |
|
|
718 gen_unaryop_tests |
|
|
719 gen_elementop_tests |
|
|
720 gen_sparsesparse_elementop_tests |
|
|
721 gen_matrixop_tests |
|
|
722 # gen_divop_tests # Disable rectangular \ and / for now |
|
|
723 gen_matrixdiag_tests |
|
|
724 gen_matrixreshape_tests |
|
|
725 } |
|
|
726 |
|
|
727 |
|
|
728 # ======================================================= |
|
|
729 # sparse assembly tests |
|
|
730 |
|
|
731 gen_assembly_tests() { |
|
|
732 cat >>$TESTS <<EOF |
|
|
733 %%Assembly tests |
|
|
734 %!test |
|
|
735 %! m=max([m;r(:)]); |
|
|
736 %! n=max([n;c(:)]); |
|
|
737 %! funiq=fsum=zeros(m,n); |
|
|
738 %! funiq(r(:) + m*(c(:)-1) ) = ones(size(r(:))); |
|
|
739 %! funiq = sparse(funiq); |
|
|
740 %! for k=1:length(r), fsum(r(k),c(k)) += 1; end |
|
|
741 %! fsum = sparse(fsum); |
|
|
742 %!assert(sparse(r,c,1),sparse(fsum(1:max(r),1:max(c)))); |
|
|
743 %!assert(sparse(r,c,1,"sum"),sparse(fsum(1:max(r),1:max(c)))); |
|
|
744 %!assert(sparse(r,c,1,"unique"),sparse(funiq(1:max(r),1:max(c)))); |
|
|
745 %!assert(sparse(r,c,1,m,n),sparse(fsum)); |
|
|
746 %!assert(sparse(r,c,1,m,n,"sum"),sparse(fsum)); |
|
|
747 %!assert(sparse(r,c,1,m,n,"unique"),sparse(funiq)); |
|
|
748 |
|
|
749 %!assert(sparse(r,c,1i),sparse(fsum(1:max(r),1:max(c))*1i)); |
|
|
750 %!assert(sparse(r,c,1i,"sum"),sparse(fsum(1:max(r),1:max(c))*1i)); |
|
|
751 %!assert(sparse(r,c,1i,"unique"),sparse(funiq(1:max(r),1:max(c))*1i)); |
|
|
752 %!assert(sparse(r,c,1i,m,n),sparse(fsum*1i)); |
|
|
753 %!assert(sparse(r,c,1i,m,n,"sum"),sparse(fsum*1i)); |
|
|
754 %!assert(sparse(r,c,1i,m,n,"unique"),sparse(funiq*1i)); |
|
|
755 |
|
|
756 %!test |
|
|
757 %! if (issparse(funiq)) |
|
|
758 %! assert(sparse(full(1i*funiq)),sparse(1i*funiq)); |
|
|
759 %! endif |
|
|
760 |
|
|
761 %!assert(sparse(full(funiq)),funiq); |
|
|
762 |
|
|
763 |
|
|
764 EOF |
|
|
765 } |
|
|
766 |
|
|
767 # ======================================================= |
|
|
768 # sparse selection tests |
|
|
769 |
|
|
770 gen_select_tests() { |
|
|
771 cat >>$TESTS <<EOF |
|
|
772 %!test as=sparse(af); |
|
|
773 |
|
|
774 %% Point tests |
|
|
775 %!test idx=ridx(:)+rows(as)*(cidx(:)-1); |
|
|
776 %!assert(sparse(as(idx),true),sparse(af(idx),true)); |
|
|
777 %!assert(as(idx),sparse(af(idx),true)); |
|
|
778 %!assert(as(idx'),sparse(af(idx'),true)); |
|
5603
|
779 %!assert(as(flipud(idx(:))),sparse(af(flipud(idx(:))),true)) |
|
5590
|
780 %!assert(as([idx,idx]),sparse(af([idx,idx]),true)); |
|
|
781 %!error(as(reshape([idx;idx],[1,length(idx),2]))); |
|
|
782 |
|
|
783 %% Slice tests |
|
|
784 %!assert(as(ridx,cidx), sparse(af(ridx,cidx),true)) |
|
|
785 %!assert(as(ridx,:), sparse(af(ridx,:),true)) |
|
|
786 %!assert(as(:,cidx), sparse(af(:,cidx),true)) |
|
|
787 %!assert(as(:,:), sparse(af(:,:),true)) |
|
5603
|
788 %!assert(as((size(as,1):-1:1),:),sparse(af((size(af,1):-1:1),:),true)) |
|
|
789 %!assert(as(:,(size(as,2):-1:1)),sparse(af(:,(size(af,2):-1:1)),true)) |
|
|
790 |
|
|
791 %% Assignment test |
|
|
792 %!test |
|
|
793 %! ts=as;ts(:,:)=ts(fliplr(1:size(as,1)),:); |
|
|
794 %! tf=af;tf(:,:)=tf(fliplr(1:size(af,1)),:); |
|
|
795 %! assert(ts,sparse(tf,true)); |
|
|
796 %!test |
|
|
797 %! ts=as;ts(fliplr(1:size(as,1)),:)=ts; |
|
|
798 %! tf=af;tf(fliplr(1:size(af,1)),:)=tf; |
|
|
799 %! assert(ts,sparse(tf,true)); |
|
|
800 %!test |
|
|
801 %! ts=as;ts(:,fliplr(1:size(as,2)))=ts; |
|
|
802 %! tf=af;tf(:,fliplr(1:size(af,2)))=tf; |
|
|
803 %! assert(ts,sparse(tf,true)); |
|
|
804 %!test |
|
|
805 %! ts(fliplr(1:size(as,1)))=as(:,1);tf(fliplr(1:size(af,1)))=af(:,1); |
|
|
806 %! assert(ts,sparse(tf,true)); |
|
|
807 |
|
|
808 %% Deletion tests |
|
|
809 %!test |
|
|
810 %! ts=as;ts(1,:)=[];tf=af;tf(1,:)=[]; |
|
|
811 %! assert(ts,sparse(tf,true)); |
|
|
812 %!test |
|
|
813 %! ts=as;ts(:,1)=[];tf=af;tf(:,1)=[]; |
|
|
814 %! assert(ts,sparse(tf,true)); |
|
5590
|
815 |
|
|
816 %% Test 'end' keyword |
|
|
817 %!assert(as(end),af(end)) |
|
|
818 %!assert(as(1,end), af(1,end)) |
|
|
819 %!assert(as(end,1), af(end,1)) |
|
|
820 %!assert(as(end,end), af(end,end)) |
|
|
821 %!assert(as(2:end,2:end), sparse(af(2:end,2:end),true)) |
|
|
822 %!assert(as(1:end-1,1:end-1), sparse(af(1:end-1,1:end-1),true)) |
|
|
823 EOF |
|
|
824 } |
|
|
825 |
|
|
826 # ======================================================= |
|
|
827 # sparse save and load tests |
|
|
828 |
|
|
829 gen_save_tests() { |
|
|
830 cat >>$TESTS <<EOF |
|
|
831 %!test # save ascii |
|
|
832 %! savefile= tmpnam(); |
|
|
833 %! as_save=as; save("-text",savefile,"bf","as_save","af"); |
|
|
834 %! clear as_save; |
|
|
835 %! load(savefile,"as_save"); |
|
|
836 %! unlink(savefile); |
|
|
837 %! assert(as_save,sparse(af)); |
|
|
838 %!test # save binary |
|
|
839 %! savefile= tmpnam(); |
|
|
840 %! as_save=as; save("-binary",savefile,"bf","as_save","af"); |
|
|
841 %! clear as_save; |
|
|
842 %! load(savefile,"as_save"); |
|
|
843 %! unlink(savefile); |
|
|
844 %! assert(as_save,sparse(af)); |
|
|
845 %!test # save hdf5 |
|
|
846 %! savefile= tmpnam(); |
|
|
847 %! as_save=as; save("-hdf5",savefile,"bf","as_save","af"); |
|
|
848 %! clear as_save; |
|
|
849 %! load(savefile,"as_save"); |
|
|
850 %! unlink(savefile); |
|
|
851 %! assert(as_save,sparse(af)); |
|
|
852 %!test # save matlab |
|
|
853 %! savefile= tmpnam(); |
|
|
854 %! as_save=as; save("-mat",savefile,"bf","as_save","af"); |
|
|
855 %! clear as_save; |
|
|
856 %! load(savefile,"as_save"); |
|
|
857 %! unlink(savefile); |
|
|
858 %! assert(as_save,sparse(af)); |
|
|
859 EOF |
|
|
860 } |
|
|
861 |
|
|
862 # ============================================================= |
|
|
863 # Specific solver tests for matrices that will test all of the solver |
|
|
864 # code. Uses alpha and beta |
|
|
865 gen_solver_tests() { |
|
|
866 |
|
|
867 if $preset; then |
|
|
868 cat >>$TESTS <<EOF |
|
|
869 %! n=8; |
|
|
870 %! lf=diag(1:n);lf(n-1,1)=0.5*alpha;lf(n,2)=0.25*alpha;ls=sparse(lf); |
|
|
871 %! uf=diag(1:n);uf(1,n-1)=2*alpha;uf(2,n)=alpha;us=sparse(uf); |
|
|
872 %! ts=spdiags(ones(n,3),-1:1,n,n)+diag(1:n); tf = full(ts); |
|
|
873 EOF |
|
|
874 else |
|
|
875 cat >>$TESTS <<EOF |
|
|
876 %! n=floor(lognormal_rnd(8,2)+1)' |
|
|
877 %! ls = tril(sprandn(8,8,0.2),-1).*alpha + n*speye(8); lf = full(ls); |
|
|
878 %! us = triu(sprandn(8,8,0.2),1).*alpha + n*speye(8); uf = full(us); |
|
|
879 %! ts = spdiags(randn(8,3),-1:1,8,8).*alpha; tf = full(ts); |
|
|
880 EOF |
|
|
881 fi |
|
|
882 |
|
|
883 cat >>$TESTS <<EOF |
|
|
884 %! df = diag(1:n).* alpha; ds = sparse(df); |
|
|
885 %! pdf = df(randperm(n),randperm(n)); pds = sparse(pdf); |
|
|
886 %! plf = lf(randperm(n),randperm(n)); pls = sparse(plf); |
|
|
887 %! puf = uf(randperm(n),randperm(n)); pus = sparse(puf); |
|
|
888 %! bs = spdiags(repmat([1:n]',1,4),-2:1,n,n).*alpha; bf = full(bs); |
|
|
889 %! cf = lf + lf'; cs = sparse(cf); |
|
|
890 %! bcf = bf + bf'; bcs = sparse(bcf); |
|
|
891 %! tcf = tf + tf'; tcs = sparse(tcf); |
|
|
892 %! xf = diag(1:n) + fliplr(diag(1:n)).*beta; xs = sparse(xf); |
|
|
893 %!assert(ds\xf,df\xf),1e-10; |
|
|
894 %!assert(ds\xs,sparse(df\xf,1),1e-10); |
|
|
895 %!assert(pds\xf,pdf\xf,1e-10); |
|
|
896 %!assert(pds\xs,sparse(pdf\xf,1),1e-10); |
|
|
897 %!assert(ls\xf,lf\xf,1e-10); |
|
|
898 %!assert(sparse(ls\xs),sparse(lf\xf),1e-10); |
|
|
899 %!assert(pls\xf,plf\xf,1e-10); |
|
|
900 %!assert(sparse(pls\xs),sparse(plf\xf),1e-10); |
|
|
901 %!assert(us\xf,uf\xf,1e-10); |
|
|
902 %!assert(sparse(us\xs),sparse(uf\xf),1e-10); |
|
|
903 %!assert(pus\xf,puf\xf,1e-10); |
|
|
904 %!assert(sparse(pus\xs),sparse(puf\xf),1e-10); |
|
|
905 %!assert(bs\xf,bf\xf,1e-10); |
|
|
906 %!assert(sparse(bs\xs),sparse(bf\xf),1e-10); |
|
|
907 %!assert(cs\xf,cf\xf,1e-10); |
|
|
908 %!assert(sparse(cs\xs),sparse(cf\xf),1e-10); |
|
|
909 %!assert(bcs\xf,bcf\xf,1e-10); |
|
|
910 %!assert(sparse(bcs\xs),sparse(bcf\xf),1e-10); |
|
|
911 %!assert(ts\xf,tf\xf,1e-10); |
|
|
912 %!assert(sparse(ts\xs),sparse(tf\xf),1e-10); |
|
|
913 %!assert(tcs\xf,tcf\xf,1e-10); |
|
|
914 %!assert(sparse(tcs\xs),sparse(tcf\xf),1e-10); |
|
|
915 |
|
|
916 EOF |
|
5610
|
917 |
|
|
918 cat >>$TESTS <<EOF |
|
|
919 %% QR solver tests |
|
|
920 |
|
|
921 %!function f(a, sz, feps) |
|
|
922 %! b = randn(sz); x = a \b; |
|
|
923 %! assert (a * x, b, feps); |
|
|
924 %! b = randn(sz)+1i*randn(sz); x = a \ b; |
|
|
925 %! assert (a * x, b, feps); |
|
|
926 %! b = sprandn(sz(1),sz(2),0.2); x = a \b; |
|
|
927 %! assert (sparse(a * x), b, feps); |
|
|
928 %! b = sprandn(sz(1),sz(2),0.2)+1i*sprandn(sz(1),sz(2),0.2); x = a \b; |
|
|
929 %! assert (sparse(a * x), b, feps); |
|
|
930 %!test |
|
|
931 %! a = alpha*sprandn(10,11,0.2)+speye(10,11); f(a,[10,2],1e-10); |
|
5630
|
932 %! ## Test this by forcing matrix_type, as can't get a certain |
|
|
933 %! ## result for over-determined systems. |
|
5610
|
934 %! a = alpha*sprandn(10,10,0.2)+speye(10,10); matrix_type(a, "Singular"); |
|
|
935 %! f(a,[10,2],1e-10); |
|
|
936 |
|
5630
|
937 %% Rectanguar solver tests that don't use QR |
|
|
938 |
|
|
939 %!test |
|
|
940 %! ds = alpha * spdiags([1:11]',0,10,11); |
|
|
941 %! df = full(ds); |
|
5681
|
942 %! xf = beta * ones(10,2); |
|
5630
|
943 %! xs = speye(10,10); |
|
|
944 %!assert(ds\xf,df\xf,100*eps) |
|
|
945 %!assert(ds\xs,sparse(df\xs,true),100*eps) |
|
|
946 %!test |
|
|
947 %! pds = ds([2,1,3:10],:); |
|
|
948 %! pdf = full(pds); |
|
|
949 %!assert(pds\xf,pdf\xf,100*eps) |
|
|
950 %!assert(pds\xs,sparse(pdf\xs,true),100*eps) |
|
|
951 %!test |
|
|
952 %! ds = alpha * spdiags([1:11]',0,11,10); |
|
|
953 %! df = full(ds); |
|
5681
|
954 %! xf = beta * ones(11,2); |
|
5630
|
955 %! xs = speye(11,11); |
|
|
956 %!assert(ds\xf,df\xf,100*eps) |
|
|
957 %!assert(ds\xs,sparse(df\xs,true),100*eps) |
|
|
958 %!test |
|
|
959 %! pds = ds([2,1,3:11],:); |
|
|
960 %! pdf = full(pds); |
|
|
961 %!assert(pds\xf,pdf\xf,100*eps) |
|
|
962 %!assert(pds\xs,sparse(pdf\xs,true),100*eps) |
|
|
963 %!test |
|
|
964 %! us = alpha*[[speye(10,10);sparse(1,10)],[[1,1];sparse(9,2);[1,1]]]; |
|
|
965 %!assert(us*(us\xf),xf,100*eps) |
|
|
966 %!assert(us*(us\xs),xs,100*eps) |
|
|
967 %!test |
|
|
968 %! pus = us(:,[2,1,3:12]); |
|
|
969 %!assert(pus*(pus\xf),xf,100*eps) |
|
|
970 %!assert(pus*(pus\xs),xs,100*eps) |
|
|
971 %!test |
|
|
972 %! us = alpha*[speye(11,9),[1;sparse(8,1);1;0]]; |
|
|
973 %!test |
|
|
974 %! [c,r] = spqr (us, xf); |
|
|
975 %! assert(us\xf,r\c,100*eps) |
|
|
976 %!test |
|
|
977 %! [c,r] = spqr (us, xs); |
|
5681
|
978 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
979 %! assert(us\xs,r\c,100*eps) |
|
|
980 %!test |
|
|
981 %! pus = us(:,[1:8,10,9]); |
|
|
982 %!test |
|
|
983 %! [c,r] = spqr (pus, xf); |
|
5681
|
984 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
985 %! assert(pus\xf,r\c,100*eps) |
|
|
986 %!test |
|
|
987 %! [c,r] = spqr (pus, xs); |
|
5681
|
988 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
989 %! assert(pus\xs,r\c,100*eps) |
|
|
990 %!test |
|
|
991 %! ls = alpha*[speye(9,11);[1,sparse(1,8),1,0]]; |
|
5681
|
992 %! xf = beta * ones(10,2); |
|
5630
|
993 %! xs = speye(10,10); |
|
|
994 %!assert(ls*(ls\xf),xf,100*eps) |
|
|
995 %!assert(ls*(ls\xs),xs,100*eps) |
|
|
996 %!test |
|
|
997 %! pls = ls([1:8,10,9],:); |
|
|
998 %!assert(pls*(pls\xf),xf,100*eps) |
|
|
999 %!assert(pls*(pls\xs),xs,100*eps) |
|
|
1000 %!test |
|
|
1001 %! ls = alpha*[speye(10,10),sparse(10,1);[1;1],sparse(2,9),[1;1]]; |
|
5681
|
1002 %! xf = beta * ones(12,2); |
|
5630
|
1003 %! xs = speye(12,12); |
|
|
1004 %!test |
|
|
1005 %! [c,r] = spqr (ls, xf); |
|
|
1006 %! assert(ls\xf,r\c,100*eps) |
|
|
1007 %!test |
|
|
1008 %! [c,r] = spqr (ls, xs); |
|
5681
|
1009 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
1010 %! assert(ls\xs,r\c,100*eps) |
|
|
1011 %!test |
|
|
1012 %! pls = ls(:,[1:8,10,9]); |
|
|
1013 %!test |
|
|
1014 %! [c,r] = spqr (pls, xf); |
|
5681
|
1015 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
1016 %! assert(pls\xf,r\c,100*eps) |
|
|
1017 %!test |
|
|
1018 %! [c,r] = spqr (pls, xs); |
|
5681
|
1019 %! r = matrix_type(r,"Singular"); ## Force Matrix Type |
|
5630
|
1020 %! assert(pls\xs,r\c,100*eps) |
|
|
1021 |
|
5610
|
1022 EOF |
|
5590
|
1023 } |
|
|
1024 |
|
|
1025 |
|
|
1026 # ============================================================= |
|
|
1027 # Putting it all together: defining the combined tests |
|
|
1028 |
|
|
1029 |
|
|
1030 # initial function |
|
|
1031 gen_function |
|
|
1032 gen_section |
|
|
1033 |
|
|
1034 # specific tests |
|
|
1035 if $preset; then |
|
|
1036 gen_specific_tests |
|
|
1037 gen_section |
|
|
1038 fi |
|
|
1039 |
|
|
1040 # scalar operations |
|
|
1041 echo '%!shared as,af,bs,bf' >> $TESTS |
|
|
1042 if $preset; then |
|
|
1043 echo '%!test af=[1+1i,2-1i,0,0;0,0,0,3+2i;0,0,0,4];' >> $TESTS |
|
|
1044 echo '%!test bf=3;' >>$TESTS |
|
|
1045 else |
|
|
1046 cat >>$TESTS <<EOF |
|
|
1047 %!test |
|
|
1048 %! % generate m,n from 1 to <5000 |
|
|
1049 %! m=floor(lognormal_rnd(8,2)+1); |
|
|
1050 %! n=floor(lognormal_rnd(8,2)+1); |
|
|
1051 %! as=sprandn(m,n,0.3); af = full(as+1i*sprandn(as)); |
|
|
1052 %! bf = randn; |
|
|
1053 EOF |
|
|
1054 fi |
|
|
1055 |
|
|
1056 gen_scalar_tests |
|
|
1057 gen_section |
|
|
1058 |
|
|
1059 # rectangular operations |
|
|
1060 if $preset; then |
|
|
1061 echo '%!test af=[1+1i,2-1i,0,0;0,0,0,3+2i;0,0,0,4];' >> $TESTS |
|
|
1062 echo '%!test bf=[0,1-1i,0,0;2+1i,0,0,0;3-1i,2+3i,0,0];' >> $TESTS |
|
|
1063 else |
|
|
1064 cat >>$TESTS <<EOF |
|
|
1065 %!test |
|
|
1066 %! m=floor(lognormal_rnd(8,2)+1); |
|
|
1067 %! n=floor(lognormal_rnd(8,2)+1); |
|
|
1068 %! as=sprandn(m,n,0.3); af = full(as+1i*sprandn(as)); |
|
|
1069 %! bs=sprandn(m,n,0.3); bf = full(bs+1i*sprandn(bs)); |
|
|
1070 EOF |
|
|
1071 fi |
|
|
1072 |
|
|
1073 gen_rectangular_tests |
|
|
1074 gen_section |
|
|
1075 gen_save_tests |
|
|
1076 gen_section |
|
|
1077 echo '%!test bf=real(bf);' >> $TESTS |
|
|
1078 gen_rectangular_tests |
|
|
1079 gen_section |
|
|
1080 gen_sparsesparse_ordering_tests |
|
|
1081 gen_section |
|
|
1082 echo '%!test af=real(af);' >> $TESTS |
|
|
1083 gen_rectangular_tests |
|
|
1084 gen_section |
|
|
1085 gen_save_tests |
|
|
1086 gen_section |
|
|
1087 echo '%!test bf=bf+1i*(bf~=0);' >> $TESTS |
|
|
1088 gen_rectangular_tests |
|
|
1089 gen_section |
|
|
1090 |
|
|
1091 # square operations |
|
|
1092 if $preset; then |
|
|
1093 echo '%!test af=[1+1i,2-1i,0,0;0,0,0,3+2i;0,0,0,4];' >> $TESTS |
|
|
1094 echo '%! as=sparse(af);' >> $TESTS |
|
|
1095 echo '%!test bf=[0,1-1i,0,0;2+1i,0,0,0;3-1i,2+3i,0,0];' >> $TESTS |
|
|
1096 else |
|
|
1097 cat >>$TESTS <<EOF |
|
|
1098 %!test |
|
|
1099 %! m=floor(lognormal_rnd(8,2)+1); |
|
|
1100 %! n=floor(lognormal_rnd(8,2)+1); |
|
|
1101 %! as=sprandn(m,n,0.3); af = full(as+1i*sprandn(as)); |
|
|
1102 %! bs=sprandn(m,n,0.3); bf = full(bs+1i*sprandn(bs)); |
|
|
1103 EOF |
|
|
1104 fi |
|
|
1105 |
|
|
1106 cat >>$TESTS <<EOF |
|
|
1107 %!test ;# invertible matrix |
|
|
1108 %! bf=af'*bf+max(abs([af(:);bf(:)]))*sparse(eye(columns(as))); |
|
|
1109 %! bs=sparse(bf); |
|
|
1110 |
|
|
1111 EOF |
|
|
1112 |
|
|
1113 gen_square_tests |
|
|
1114 gen_section |
|
|
1115 echo '%!test bf=real(bf);' >> $TESTS |
|
|
1116 echo '%! bs=sparse(bf);' >> $TESTS |
|
|
1117 gen_square_tests |
|
|
1118 gen_section |
|
|
1119 echo '%!test af=real(af);' >> $TESTS |
|
|
1120 echo '%! as=sparse(af);' >> $TESTS |
|
|
1121 gen_square_tests |
|
|
1122 gen_section |
|
|
1123 echo '%!test bf=bf+1i*(bf~=0);' >> $TESTS |
|
|
1124 echo '%! bs=sparse(bf);' >> $TESTS |
|
|
1125 gen_square_tests |
|
|
1126 gen_section |
|
|
1127 |
|
|
1128 # cholesky tests |
|
|
1129 if $preset; then |
|
|
1130 echo '%!test bf=[5,0,1+1i,0;0,5,0,1-2i;1-1i,0,5,0;0,1+2i,0,5];' >> $TESTS |
|
|
1131 echo '%! bs=sparse(bf);' >> $TESTS |
|
|
1132 else |
|
|
1133 echo '# This has a small chance of failing to create a positive definite matrix' >> $TESTS |
|
|
1134 echo '%!test n=floor(lognormal_rnd(8,2)+1)' >> $TESTS |
|
|
1135 echo '%! bs = n*speye(n,n) + sprandn(n,n,0.3); bf = full(bs);' >> $TESTS |
|
|
1136 fi |
|
|
1137 |
|
|
1138 gen_cholesky_tests |
|
|
1139 gen_section |
|
|
1140 echo '%!test bf=real(bf);' >> $TESTS |
|
|
1141 echo '%! bs=sparse(bf);' >> $TESTS |
|
|
1142 gen_cholesky_tests |
|
|
1143 gen_section |
|
|
1144 |
|
|
1145 # assembly tests |
|
|
1146 echo '%!shared r,c,m,n,fsum,funiq' >>$TESTS |
|
|
1147 if $use_preset; then |
|
|
1148 cat >>$TESTS <<EOF |
|
|
1149 %!test |
|
|
1150 %! r=[1,1,2,1,2,3]; |
|
|
1151 %! c=[2,1,1,1,2,1]; |
|
|
1152 %! m=n=0; |
|
|
1153 EOF |
|
|
1154 else |
|
|
1155 cat >>$TESTS <<EOF |
|
|
1156 %!test |
|
|
1157 %! % generate m,n from 1 to <5000 |
|
|
1158 %! m=floor(lognormal_rnd(8,2)+1); |
|
|
1159 %! n=floor(lognormal_rnd(8,2)+1); |
|
|
1160 %! nz=ceil((m+n)/2); |
|
|
1161 %! r=floor(rand(5,nz)*n)+1; |
|
|
1162 %! c=floor(rand(5,nn)*m)+1; |
|
|
1163 EOF |
|
|
1164 fi |
|
|
1165 gen_assembly_tests #includes real and complex tests |
|
|
1166 gen_section |
|
|
1167 |
|
|
1168 # slicing tests |
|
|
1169 echo '%!shared ridx,cidx,idx,as,af' >>$TESTS |
|
|
1170 if $use_preset; then |
|
|
1171 cat >>$TESTS <<EOF |
|
|
1172 %!test |
|
|
1173 %! af=[1+1i,2-1i,0,0;0,0,0,3+2i;0,0,0,4]; |
|
|
1174 %! ridx=[1,3]; cidx=[2,3]; |
|
|
1175 EOF |
|
|
1176 else |
|
|
1177 cat >>$TESTS <<EOF |
|
|
1178 %!test |
|
|
1179 %! % generate m,n from 1 to <5000 |
|
|
1180 %! m=floor(lognormal_rnd(8,2)+1); |
|
|
1181 %! n=floor(lognormal_rnd(8,2)+1); |
|
|
1182 %! as=sprandn(m,n,0.3); af = full(as+1i*sprandn(as)); |
|
|
1183 %! ridx = ceil(m*rand(1,ceil(rand*m)) |
|
|
1184 %! cidx = ceil(n*rand(1,ceil(rand*n)) |
|
|
1185 EOF |
|
|
1186 fi |
|
|
1187 gen_select_tests |
|
|
1188 echo '%!test af=real(af);' >> $TESTS |
|
|
1189 gen_select_tests |
|
|
1190 gen_section |
|
|
1191 echo '%!shared alpha,beta,df,pdf,lf,plf,uf,puf,bf,cf,bcf,tf,tcf,xf,ds,pds,ls,pls,us,pus,bs,cs,bcs,ts,tcs,xs' >>$TESTS |
|
|
1192 echo '%!test alpha=1;beta=1;' >> $TESTS |
|
|
1193 gen_solver_tests |
|
|
1194 echo '%!test alpha=1;beta=1i;' >> $TESTS |
|
|
1195 gen_solver_tests |
|
|
1196 echo '%!test alpha=1i;beta=1;' >> $TESTS |
|
|
1197 gen_solver_tests |
|
|
1198 echo '%!test alpha=1i;beta=1i;' >> $TESTS |
|
|
1199 gen_solver_tests |
|
|
1200 gen_section |
