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