UNPKG

8.74 kBJavaScriptView Raw
1// test lup
2var assert = require('assert'),
3 approx = require('../../../../tools/approx'),
4 math = require('../../../../index');
5
6describe('lup', function () {
7
8 it('should decompose matrix, n x n, no permutations, array', function () {
9
10 var m = [[2, 1], [1, 4]];
11
12 var r = math.lup(m);
13 // L
14 assert.deepEqual(r.L.valueOf(), [[1, 0], [0.5, 1]]);
15 // U
16 assert.deepEqual(r.U.valueOf(), [[2, 1], [0, 3.5]]);
17 // P
18 assert.deepEqual(r.p, [0, 1]);
19 // verify
20 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
21 });
22
23 it('should decompose matrix, n x n, no permutations, sparse', function () {
24
25 var m = math.matrix([[2, 1], [1, 4]], 'sparse');
26
27 var r = math.lup(m);
28 // L
29 assert.deepEqual(r.L.valueOf(), [[1, 0], [0.5, 1]]);
30 // U
31 assert.deepEqual(r.U.valueOf(), [[2, 1], [0, 3.5]]);
32 // P
33 assert.deepEqual(r.p, [0, 1]);
34 // verify
35 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
36 });
37
38 it('should decompose matrix, n x n, no permutations, dense format', function () {
39
40 var m = math.matrix([[2, 1], [1, 4]], 'dense');
41
42 var r = math.lup(m);
43 // L
44 assert.deepEqual(r.L.valueOf(), [[1, 0], [0.5, 1]]);
45 // U
46 assert.deepEqual(r.U.valueOf(), [[2, 1], [0, 3.5]]);
47 // P
48 assert.deepEqual(r.p, [0, 1]);
49 // verify
50 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
51 });
52
53 it('should decompose matrix, m x n, m < n, no permutations, dense format', function () {
54 var m = math.matrix(
55 [
56 [2, 1, 1],
57 [1, 4, 5]
58 ]
59 );
60
61 var r = math.lup(m);
62 // L
63 assert.deepEqual(
64 r.L,
65 math.matrix(
66 [
67 [1, 0],
68 [0.5, 1]
69 ]
70 ));
71 // U
72 assert.deepEqual(
73 r.U,
74 math.matrix(
75 [
76 [2, 1, 1],
77 [0, 3.5, 4.5]
78 ]
79 ));
80 // P
81 assert.deepEqual(r.p, [0, 1]);
82 // verify
83 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
84 });
85
86 it('should decompose matrix, m x n, m > n, no permutations, dense format', function () {
87 var m = math.matrix(
88 [
89 [8, 2],
90 [6, 4],
91 [4, 1]
92 ]
93 );
94
95 var r = math.lup(m);
96 // L
97 assert.deepEqual(
98 r.L,
99 math.matrix(
100 [
101 [1, 0],
102 [0.75, 1],
103 [0.5, 0]
104 ]
105 ));
106 // U
107 assert.deepEqual(
108 r.U,
109 math.matrix(
110 [
111 [8, 2],
112 [0, 2.5]
113 ]
114 ));
115 // P
116 assert.deepEqual(r.p, [0, 1, 2]);
117 // verify
118 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
119 });
120
121 it('should decompose matrix, n x n, dense format', function () {
122 var m = math.matrix(
123 [
124 [16, -120, 240, -140],
125 [-120, 1200, -2700, 1680],
126 [240, -2700, 6480, -4200],
127 [-140, 1680, -4200, 2800]
128 ]
129 );
130
131 var r = math.lup(m);
132 // L
133 approx.deepEqual(
134 r.L.valueOf(),
135 [
136 [1, 0, 0, 0],
137 [-0.5, 1, 0, 0],
138 [-0.5833333333333334, -0.7, 1, 0],
139 [0.06666666666666667, -0.4, -0.5714285714285776, 1]
140 ]);
141 // U
142 approx.deepEqual(
143 r.U.valueOf(),
144 [
145 [240, -2700, 6480, -4200],
146 [0, -150, 540, -420],
147 [0, 0, -42, 56],
148 [0, 0, 0, 4]
149 ]);
150 // P
151 assert.deepEqual(r.p, [3, 1, 0, 2]);
152 // verify
153 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
154 });
155
156 it('should decompose matrix, 3 x 3, zero pivote value, dense format', function () {
157 var m = math.matrix(
158 [
159 [1, 2, 3],
160 [2, 4, 6],
161 [4, 8, 9]
162 ]);
163
164 var r = math.lup(m);
165 // L
166 approx.deepEqual(
167 r.L.valueOf(),
168 [
169 [1, 0, 0],
170 [0.5, 1, 0],
171 [0.25, 0, 1.0]
172 ]);
173 // U
174 approx.deepEqual(
175 r.U.valueOf(),
176 [
177 [4, 8, 9],
178 [0, 0, 1.5],
179 [0, 0, 0.75]
180 ]);
181 // P
182 assert.deepEqual(r.p, [2, 1, 0]);
183 // verify
184 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
185 });
186
187 it('should decompose matrix, 3 x 2, complex numbers, dense format', function () {
188 var m = math.matrix(
189 [
190 [math.complex(0, 3), 10],
191 [math.complex(0, 1), 1],
192 [math.complex(0, 1), 1]
193 ]);
194
195 var r = math.lup(m);
196 // L
197 approx.deepEqual(
198 r.L.valueOf(),
199 [
200 [1, 0],
201 [math.complex(0.3333333, 0), 1],
202 [math.complex(0.3333333, 0), 1]
203 ]);
204 // U
205 approx.deepEqual(
206 r.U.valueOf(),
207 [
208 [math.complex(0, 3), 10],
209 [0, math.complex(-2.3333333333, 0)]
210 ]);
211 // P
212 assert.deepEqual(r.p, [0, 1, 2]);
213 // verify
214 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
215 });
216
217 it('should decompose matrix, m x n, m < n, no permutations, sparse', function () {
218 var m = math.matrix(
219 [
220 [2, 1, 1],
221 [1, 4, 5]
222 ],
223 'sparse');
224
225 var r = math.lup(m);
226 // L
227 assert.deepEqual(
228 r.L.valueOf(),
229 [
230 [1, 0],
231 [0.5, 1]
232 ]);
233 // U
234 assert.deepEqual(
235 r.U.valueOf(),
236 [
237 [2, 1, 1],
238 [0, 3.5, 4.5]
239 ]);
240 // P
241 assert.deepEqual(r.p, [0, 1]);
242 // verify
243 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
244 });
245
246 it('should decompose matrix, m x n, m > n, no permutations, sparse', function () {
247 var m = math.matrix(
248 [
249 [8, 2],
250 [6, 4],
251 [4, 1]
252 ],
253 'sparse');
254
255 var r = math.lup(m);
256 // L
257 assert.deepEqual(
258 r.L.valueOf(),
259 [
260 [1, 0],
261 [0.75, 1],
262 [0.5, 0]
263 ]);
264 // U
265 assert.deepEqual(
266 r.U.valueOf(),
267 [
268 [8, 2],
269 [0, 2.5]
270 ]);
271 // P
272 assert.deepEqual(r.p, [0, 1, 2]);
273 // verify
274 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
275 });
276
277 it('should decompose matrix, n x n, sparse', function () {
278 var m = math.matrix(
279 [
280 [16, -120, 240, -140],
281 [-120, 1200, -2700, 1680],
282 [240, -2700, 6480, -4200],
283 [-140, 1680, -4200, 2800]
284 ],
285 'sparse');
286
287 var r = math.lup(m);
288 // L
289 approx.deepEqual(
290 r.L.valueOf(),
291 [
292 [1, 0, 0, 0],
293 [-0.5, 1, 0, 0],
294 [-0.5833333333333334, -0.7, 1, 0],
295 [0.06666666666666667, -0.4, -0.5714285714285776, 1]
296 ]);
297 // U
298 approx.deepEqual(
299 r.U.valueOf(),
300 [
301 [240, -2700, 6480, -4200],
302 [0, -150, 540, -420],
303 [0, 0, -42, 56],
304 [0, 0, 0, 4]
305 ]);
306 // P
307 assert.deepEqual(r.p, [3, 1, 0, 2]);
308 // verify
309 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
310 });
311
312 it('should decompose matrix, 3 x 3, zero pivote value, sparse', function () {
313 var m = math.matrix(
314 [
315 [1, 2, 3],
316 [2, 4, 6],
317 [4, 8, 9]
318 ],
319 'sparse');
320
321 var r = math.lup(m);
322 // L
323 approx.deepEqual(
324 r.L.valueOf(),
325 [
326 [1, 0, 0],
327 [0.5, 1, 0],
328 [0.25, 0, 1.0]
329 ]);
330 // U
331 approx.deepEqual(
332 r.U.valueOf(),
333 [
334 [4, 8, 9],
335 [0, 0, 1.5],
336 [0, 0, 0.75]
337 ]);
338 // P
339 assert.deepEqual(r.p, [2, 1, 0]);
340 // verify
341 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
342 });
343
344 it('should decompose matrix, 3 x 2, complex numbers, sparse', function () {
345 var m = math.matrix(
346 [
347 [math.complex(0, 3), 10],
348 [math.complex(0, 1), 1],
349 [math.complex(0, 1), 1]
350 ], 'sparse');
351
352 var r = math.lup(m);
353 // L
354 approx.deepEqual(
355 r.L.valueOf(),
356 [
357 [1, 0],
358 [math.complex(0.3333333, 0), 1],
359 [math.complex(0.3333333, 0), 1]
360 ]);
361 // U
362 approx.deepEqual(
363 r.U.valueOf(),
364 [
365 [math.complex(0, 3), 10],
366 [0, math.complex(-2.3333333333, 0)]
367 ]);
368 // P
369 assert.deepEqual(r.p, [0, 1, 2]);
370 // verify
371 approx.deepEqual(math.multiply(_p(r.p), m).valueOf(), math.multiply(r.L, r.U).valueOf());
372 });
373
374 /**
375 * Creates a Matrix out of a row permutation vector
376 */
377 function _p(p) {
378 // identity matrix
379 var identity = math.eye(p.length);
380 // array
381 var data = [];
382 // loop rows
383 for (var i = 0, l = p.length; i < l; i++) {
384 // swap row
385 data[p[i]] = identity._data[i];
386 }
387 return data;
388 }
389});