Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.vector;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.SortedMap;
011
012import edu.jas.arith.BigRational;
013import edu.jas.arith.BigInteger;
014import edu.jas.arith.ModLong;
015import edu.jas.arith.ModLongRing;
016import edu.jas.poly.GenPolynomial;
017import edu.jas.poly.GenPolynomialRing;
018import edu.jas.ufd.FactorAbstract;
019import edu.jas.ufd.FactorFactory;
020import edu.jas.kern.ComputerThreads;
021
022import junit.framework.Test;
023import junit.framework.TestCase;
024import junit.framework.TestSuite;
025
026
027/**
028 * GenMatrix tests with JUnit
029 * @author Heinz Kredel
030 */
031
032public class GenMatrixTest extends TestCase {
033
034
035    /**
036     * main.
037     */
038    public static void main(String[] args) {
039        junit.textui.TestRunner.run(suite());
040    }
041
042
043    /**
044     * Constructs a <CODE>GenMatrixTest</CODE> object.
045     * @param name String.
046     */
047    public GenMatrixTest(String name) {
048        super(name);
049    }
050
051
052    /**
053     */
054    public static Test suite() {
055        TestSuite suite = new TestSuite(GenMatrixTest.class);
056        return suite;
057    }
058
059
060    int rl = 5;
061
062
063    int kl = 10;
064
065
066    int ll = 10;
067
068
069    float q = 0.5f;
070
071
072    int rows = 3 + 20;
073
074
075    int cols = 3 + 20;
076
077
078    @Override
079    protected void setUp() {
080    }
081
082
083    @Override
084    protected void tearDown() {
085    }
086
087
088    /**
089     * Test constructor and toString.
090     */
091    public void testConstruction() {
092        BigRational cfac = new BigRational(1);
093        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
094
095        assertTrue("#rows = " + rows, mfac.rows == rows);
096        assertTrue("#columns = " + cols, mfac.cols == cols);
097        assertTrue("cfac == coFac ", cfac == mfac.coFac);
098
099        GenMatrix<BigRational> a;
100        a = mfac.getZERO();
101        //System.out.println("a = " + a);
102        assertTrue("isZERO( a )", a.isZERO());
103
104        GenMatrix<BigRational> b = new GenMatrix<BigRational>(mfac);
105        //System.out.println("b = " + b);
106        assertTrue("isZERO( b )", b.isZERO());
107
108        assertTrue("a == b ", a.equals(b));
109
110        GenMatrix<BigRational> c = b.copy();
111        //System.out.println("c = " + c);
112        assertTrue("isZERO( c )", c.isZERO());
113        assertTrue("a == c ", a.equals(c));
114
115        GenMatrix<BigRational> d = mfac.copy(b);
116        //System.out.println("d = " + d);
117        assertTrue("isZERO( d )", d.isZERO());
118        assertTrue("a == d ", a.equals(d));
119
120        a = mfac.getONE();
121        //System.out.println("a = " + a);
122        assertTrue("isONE( a )", a.isONE());
123
124        List<ArrayList<BigRational>> m = a.matrix;
125        List<List<BigRational>> ml = new ArrayList<List<BigRational>>(m.size());
126        for (ArrayList<BigRational> r : m) {
127            ml.add(r);
128        }
129        b = mfac.fromList(ml);
130        assertEquals("a == fromList(a.matrix)", a, b);
131
132        GenMatrix<BigRational> e = mfac.generate((i, j) -> cfac.getZERO());
133        //System.out.println("e = " + e);
134        assertTrue("e == 0: ", e.isZERO());
135
136        e = mfac.generate((i, j) -> i == j ? cfac.getONE() : cfac.getZERO());
137        //System.out.println("e = " + e);
138        assertTrue("e == 1: ", e.isONE());
139
140        e = mfac.generate((i, j) -> i == j + 1 ? cfac.getONE() : cfac.getZERO());
141        //System.out.println("e = " + e);
142        assertTrue("e**" + mfac.cols + " == 0: ", e.power(mfac.cols).isZERO());
143    }
144
145
146    /**
147     * Test random matrix.
148     */
149    public void testRandom() {
150        BigRational cfac = new BigRational(1);
151        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
152        GenMatrixRing<BigRational> tfac = mfac.transpose();
153
154        if (rows == cols) {
155            assertTrue(" mfac = tfac ", mfac.equals(tfac));
156        }
157
158        GenMatrix<BigRational> a, b, c;
159
160        for (int i = 0; i < 5; i++) {
161            a = mfac.random(kl, q);
162            //System.out.println("a = " + a);
163            if (a.isZERO()) {
164                continue;
165            }
166            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
167            b = a.transpose(tfac);
168            //System.out.println("b = " + b);
169            assertTrue(" not isZERO( b" + i + " )", !b.isZERO());
170            c = b.transpose(mfac);
171            //System.out.println("c = " + c);
172            assertEquals(" a^r^r == a ", a, c);
173        }
174    }
175
176
177    /**
178     * Test addition.
179     */
180    public void testAddition() {
181        BigRational cfac = new BigRational(1);
182        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
183        GenMatrix<BigRational> a, b, c, d, e;
184
185        a = mfac.random(kl, q);
186        b = mfac.random(kl, q);
187        //System.out.println("a = " + a);
188        //System.out.println("b = " + b);
189
190        c = a.sum(b);
191        d = c.subtract(b);
192        //System.out.println("c = " + c);
193        //System.out.println("d = " + d);
194        assertEquals("a+b-b = a", a, d);
195
196        c = a.sum(b);
197        d = c.sum(b.negate());
198        //System.out.println("c = " + c);
199        //System.out.println("d = " + d);
200        assertEquals("a+b+(-b) = a", a, d);
201
202        c = a.sum(b);
203        d = b.sum(a);
204        //System.out.println("c = " + c);
205        //System.out.println("d = " + d);
206        assertEquals("a+b = b+a", c, d);
207
208        c = mfac.random(kl, q);
209        d = a.sum(b).sum(c);
210        e = a.sum(b.sum(c));
211        //System.out.println("d = " + d);
212        //System.out.println("e = " + e);
213        assertEquals("a+(b+c) = (a+b)+c", d, e);
214    }
215
216
217    /**
218     * Test scalar multiplication.
219     */
220    public void testScalarMultiplication() {
221        BigRational cfac = new BigRational(1);
222        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
223        BigRational r, s, t;
224        GenMatrix<BigRational> a, b, c, d;
225
226        r = cfac.random(kl);
227        //System.out.println("r = " + r);
228        s = r.inverse();
229        //System.out.println("s = " + s);
230
231        a = mfac.random(kl, q);
232        //System.out.println("a = " + a);
233
234        c = a.scalarMultiply(r);
235        d = c.scalarMultiply(s);
236        //System.out.println("c = " + c);
237        //System.out.println("d = " + d);
238        assertEquals("a*b*(1/b) = a", a, d);
239
240        b = mfac.random(kl, q);
241        //System.out.println("b = " + b);
242
243        t = cfac.getONE();
244        //System.out.println("t = " + t);
245        c = a.linearCombination(b, t);
246        d = b.linearCombination(a, t);
247        //System.out.println("c = " + c);
248        //System.out.println("d = " + d);
249        assertEquals("a+1*b = b+1*a", c, d);
250
251        c = a.linearCombination(b, t);
252        d = a.sum(b);
253        //System.out.println("c = " + c);
254        //System.out.println("d = " + d);
255        assertEquals("a+1*b = b+1*a", c, d);
256
257        s = t.negate();
258        //System.out.println("s = " + s);
259        c = a.linearCombination(b, t);
260        d = c.linearCombination(b, s);
261        //System.out.println("c = " + c);
262        //System.out.println("d = " + d);
263        assertEquals("a+1*b+(-1)*b = a", a, d);
264
265        c = a.linearCombination(t, b, t);
266        d = c.linearCombination(t, b, s);
267        //System.out.println("c = " + c);
268        //System.out.println("d = " + d);
269        assertEquals("a*1+b*1+b*(-1) = a", a, d);
270
271        t = cfac.getZERO();
272        //System.out.println("t = " + t);
273        c = a.linearCombination(b, t);
274        //System.out.println("c = " + c);
275        assertEquals("a+0*b = a", a, c);
276
277        d = a.linearCombination(t, b, t);
278        //System.out.println("d = " + d);
279        assertEquals("0*a+0*b = 0", mfac.getZERO(), d);
280    }
281
282
283    /**
284     * Test (simple) multiplication.
285     */
286    public void testSimpleMultiplication() {
287        BigRational cfac = new BigRational(1);
288        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
289        GenMatrix<BigRational> a, b, c, d, e, f;
290
291        a = mfac.getZERO();
292        b = mfac.getZERO();
293        c = a.multiplySimple(b);
294        //System.out.println("a = " + a);
295        //System.out.println("b = " + b);
296        //System.out.println("c = " + c);
297        assertTrue("0*0 = 0 ", c.isZERO());
298
299        a = mfac.getONE();
300        b = mfac.getONE();
301        c = a.multiplySimple(b);
302        //System.out.println("a = " + a);
303        //System.out.println("b = " + b);
304        //System.out.println("c = " + c);
305        assertTrue("1*1 = 1 ", c.isONE());
306
307        a = mfac.random(kl, q);
308        b = mfac.getONE();
309        c = a.multiplySimple(b);
310        d = a.multiply(b);
311        //System.out.println("a = " + a);
312        //System.out.println("b = " + b);
313        //System.out.println("c = " + c);
314        //System.out.println("d = " + d);
315        assertEquals("a*1 = a ", a, c);
316        assertEquals("a*1 = a*1 ", c, d);
317
318        c = b.multiplySimple(a);
319        d = a.multiply(b);
320        //System.out.println("a = " + a);
321        //System.out.println("b = " + b);
322        //System.out.println("c = " + c);
323        //System.out.println("d = " + d);
324        assertEquals("1*a = a ", a, c);
325        assertEquals("a*1 = a*1 ", c, d);
326
327        b = mfac.random(kl, q);
328        long s, t;
329        s = System.currentTimeMillis();
330        c = a.multiplySimple(b);
331        s = System.currentTimeMillis() - s;
332        assertTrue("nonsense " + s, s >= 0L);
333        d = b.multiplySimple(a);
334        t = System.currentTimeMillis();
335        e = a.multiply(b);
336        t = System.currentTimeMillis() - t;
337        assertTrue("nonsense " + t, t >= 0L);
338        f = b.multiply(a);
339        //System.out.println("a = " + a);
340        //System.out.println("b = " + b);
341        //System.out.println("c = " + c);
342        //System.out.println("d = " + d);
343        //System.out.println("e = " + e);
344        //System.out.println("f = " + e);
345        //System.out.println("e = " + e);
346        assertTrue("a*b != b*a ", !c.equals(d));
347        assertEquals("a*1 = a*1 ", c, e);
348        assertEquals("a*1 = a*1 ", d, f);
349        //System.out.println("time: s = " + s + ", t = " + t);
350
351        if (!mfac.isAssociative()) {
352            return;
353        }
354        c = mfac.random(kl, q);
355
356        d = a.multiply(b.sum(c));
357        e = (a.multiply(b)).sum(a.multiply(c));
358        assertEquals("a*(b+c) = a*b+a*c", d, e);
359
360        d = a.multiply(b.multiply(c));
361        e = (a.multiply(b)).multiply(c);
362        assertEquals("a*(b*c) = (a*b)*c", d, e);
363    }
364
365
366    /**
367     * Test parse matrix.
368     */
369    public void testParse() {
370        BigRational cfac = new BigRational(1);
371        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, rows, cols);
372
373        GenMatrix<BigRational> a, c;
374
375        a = mfac.random(kl, q);
376        //System.out.println("a = " + a);
377        if (!a.isZERO()) {
378            //return;
379            assertTrue(" not isZERO( a )", !a.isZERO());
380        }
381        String s = a.toString();
382        //System.out.println("s = " + s);
383        c = mfac.parse(s);
384        //System.out.println("c = " + c);
385        assertEquals("parse(toStirng(a) == a ", a, c);
386    }
387
388
389    /**
390     * Test LU decomposition.
391     */
392    public void testLUdecomp() {
393        BigRational cfac = new BigRational(1);
394        int n = 10;
395        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, n, n);//rows, cols);
396        GenVectorModul<BigRational> vfac = new GenVectorModul<BigRational>(cfac, n);//rows);
397
398        GenMatrix<BigRational> A, Ap, iA, AiA;
399        //A = mfac.getONE().negate(); //.sum(mfac.getONE());
400        A = mfac.random(kl, 0.7f);
401        //A = mfac.parse("[ [3,4], [1,2] ]");
402        //System.out.println("A = " + A);
403        if (A.isZERO()) {
404            return;
405        }
406        assertTrue(" not isZERO( A )", !A.isZERO());
407        Ap = A.copy();
408
409        LinAlg<BigRational> lu = new LinAlg<BigRational>();
410        BasicLinAlg<BigRational> blas = new BasicLinAlg<BigRational>();
411
412        List<Integer> P = lu.decompositionLU(A);
413        //System.out.println("P = " + P);
414        //System.out.println("A = " + A);
415        if (P.size() == 0) {
416            System.out.println("undecomposable");
417            return;
418        }
419
420        GenVector<BigRational> s;
421        //b = vfac.random(kl);
422        //b = vfac.parse("[5,5]");
423        //s = vfac.parse("[1,1]");
424        s = vfac.random(kl);
425        //System.out.println("s = " + s);
426        GenVector<BigRational> b = blas.rightProduct(s, Ap);
427        //System.out.println("b = " + b);
428
429        GenVector<BigRational> x = lu.solveLU(A, P, b);
430        //System.out.println("x = " + x);
431        assertEquals("s == x: ", s, x);
432
433        GenVector<BigRational> r = blas.rightProduct(x, Ap);
434        //System.out.println("r = " + r);
435
436        //System.out.println("b == r: " + b.equals(r));
437        assertEquals("b == r: ", b, r);
438
439        BigRational det = lu.determinantLU(A, P);
440        //System.out.println("det = " + det + " ~= " + det.getDecimal());
441        assertFalse("det(A) != 0: ", det.isZERO());
442
443        iA = lu.inverseLU(A, P);
444        //System.out.println("iA = " + iA);
445        AiA = Ap.multiply(iA);
446        //System.out.println("AiA = " + AiA);
447        assertTrue("A*iA == 1: ", AiA.isONE());
448
449        GenMatrix<BigRational> I = Ap.inverse();
450        GenMatrix<BigRational> CI = Ap.multiply(I);
451        //System.out.println("C*I:   " + CI.toScript());
452        assertTrue("Ap*I == 1: ", CI.isONE());
453
454        GenMatrix<BigRational> C = mfac.random(3, 0.5f);
455        GenMatrix<BigRational> CA = C.divide(Ap);
456        GenMatrix<BigRational> AC = C.divideLeft(Ap);
457        //System.out.println("C/A :    " + CA);
458        //System.out.println("A\\C :   " + AC);
459        assertFalse("C/A != A\\C: ", CA.equals(AC));
460
461        GenMatrix<BigRational> B = CA.multiply(Ap);
462        assertEquals("C == C/A*A: ", B, C);
463        B = Ap.multiply(AC);
464        assertEquals("C == A*A\\C: ", B, C);
465    }
466
467
468    /**
469     * Test Null Space basis, modular coeffs.
470     */
471    public void testNullSpaceMod() {
472        ModLongRing cfac = new ModLongRing(11); //11, 32003
473        int n = 100;
474        GenMatrixRing<ModLong> mfac = new GenMatrixRing<ModLong>(cfac, n, n);//rows, cols);
475        //System.out.println("mfac = " + mfac.toScript());
476        //GenVectorModul<ModLong> vfac = new GenVectorModul<ModLong>(cfac, n);//rows);
477        GenMatrixRing<ModLong> tfac = mfac.transpose();
478
479        GenMatrix<ModLong> A, Ap, B, T;
480        //A = mfac.getONE(); //.negate(); //.sum(mfac.getONE());
481        A = mfac.random(kl, 0.5f / n);
482        //A = mfac.parse("[ [3,4,5], [1,2,3], [2,4,6] ]");
483        //A = mfac.parse("[ [1,0,0,0,0], [3,0,0,0,0], [0,0,1,0,0], [2,0,4,0,0], [0,0,0,0,1] ]");
484        //A = mfac.parse("[ [0,0,0,0,0,0], [3,4,-3,-3,5,5], [3,-5,5,1,-1,0], [-2,4,-1,2,-4,-2], [-4,-3,-1,0,-1,-3], [-3,-1,-4,-3,-1,-4] ]");
485        //A = A.sum( mfac.getONE() );
486        if (n < 50)
487            System.out.println("A = " + A);
488        if (A.isZERO()) {
489            return;
490        }
491        assertTrue(" not isZERO( A )", !A.isZERO());
492        Ap = A.copy();
493        T = A.transpose(tfac);
494        if (n < 10)
495            System.out.println("At = " + T);
496
497        LinAlg<ModLong> lu = new LinAlg<ModLong>();
498        BasicLinAlg<ModLong> blas = new BasicLinAlg<ModLong>();
499
500        List<GenVector<ModLong>> NSB = lu.nullSpaceBasis(A);
501        //System.out.println("NS basis = " + NSB.size());
502        if (NSB.size() == 0) {
503            System.out.println("no null space basis");
504            return;
505        }
506        if (n < 10)
507            System.out.println("mod A-I = " + A);
508        for (GenVector<ModLong> v : NSB) {
509            GenVector<ModLong> z = blas.leftProduct(v, T);
510            //System.out.println("z == 0: " + z.isZERO());
511            assertTrue("z == 0: " + z, z.isZERO());
512        }
513        // test idempotent
514        Ap = A.sum(mfac.getONE());
515        B = Ap.multiply(Ap);
516        if (!Ap.equals(B)) {
517            System.out.println("Ap = " + Ap);
518            System.out.println("B = " + B);
519        }
520        assertEquals("A*A == B: ", Ap, B);
521    }
522
523
524    /**
525     * Test Null Space basis.
526     */
527    public void testNullSpace() {
528        BigRational cfac = new BigRational(11);
529        int n = 100;
530        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, n, n);//rows, cols);
531        //System.out.println("mfac = " + mfac.toScript());
532        //GenVectorModul<BigRational> vfac = new GenVectorModul<BigRational>(cfac, n);//rows);
533        GenMatrixRing<BigRational> tfac = mfac.transpose();
534
535        GenMatrix<BigRational> A, Ap, B, T;
536        //A = mfac.getZERO(); //.negate(); //.sum(mfac.getONE());
537        //A.setMutate(4,1, cfac.parse("44") );
538        //A.setMutate(5,2, cfac.parse("22") );
539        //A.setMutate(5,3, cfac.parse("33") );
540        A = mfac.random(kl, 0.5f / n);
541        //A = mfac.parse("[ [3,4,5], [1,2,3], [2,4,6] ]");
542        //A = mfac.parse("[ [1,0,0,0,0], [3,0,0,0,0], [0,0,1,0,0], [2,0,4,0,0], [0,0,0,0,1] ]");
543        //A = mfac.parse("[ [0,0,0,0,0,0], [3,4,-3,-3,5,5], [3,-5,5,1,-1,0], [-2,4,-1,2,-4,-2], [-4,-3,-1,0,-1,-3], [-3,-1,-4,-3,-1,-4] ]");
544        //A = A.sum( mfac.getONE() ); // subtract
545        if (n < 10)
546            System.out.println("A = " + A);
547        if (A.isZERO()) {
548            return;
549        }
550        assertTrue(" not isZERO( A )", !A.isZERO());
551        Ap = A.copy();
552        T = A.transpose(tfac);
553
554        LinAlg<BigRational> lu = new LinAlg<BigRational>();
555        BasicLinAlg<BigRational> blas = new BasicLinAlg<BigRational>();
556
557        List<GenVector<BigRational>> NSB = lu.nullSpaceBasis(A);
558        //System.out.println("NS basis = " + NSB.size());
559        if (NSB.size() == 0) {
560            System.out.println("no null space basis");
561            return;
562        }
563        if (n < 10)
564            System.out.println("mod A-I = " + A);
565        if (n < 10)
566            System.out.println("T = " + T);
567        for (GenVector<BigRational> v : NSB) {
568            //System.out.println("v = " + v);
569            GenVector<BigRational> z = blas.leftProduct(v, T);
570            //System.out.println("z == 0: " + z.isZERO());
571            assertTrue("z == 0: " + z, z.isZERO());
572        }
573        // test idempotent
574        Ap = A.sum(mfac.getONE());
575        B = Ap.multiply(Ap);
576        if (!Ap.equals(B)) {
577            System.out.println("Ap = " + Ap);
578            System.out.println("B = " + B);
579        }
580        assertEquals("A*A == B: ", Ap, B);
581    }
582
583
584    /**
585     * Test Null Space basis for cokernel and kernel.
586     */
587    public void testNullSpaceKernels() {
588        BigRational cfac = new BigRational(11);
589        int n = 10;
590        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, n, n);//rows, cols);
591        //System.out.println("mfac = " + mfac.toScript());
592        GenMatrixRing<BigRational> tfac = mfac.transpose();
593
594        GenMatrix<BigRational> A, Ap, T, Tp;
595        A = mfac.random(kl, 0.7f / n);
596        if (n < 10)
597            System.out.println("A = " + A);
598        if (A.isZERO()) {
599            return;
600        }
601        assertTrue(" not isZERO( A )", !A.isZERO());
602        Ap = A.copy();
603        T = Ap.transpose(tfac);
604        Tp = T.copy();
605        if (n < 10)
606            System.out.println("T = " + T);
607
608        LinAlg<BigRational> lu = new LinAlg<BigRational>();
609        BasicLinAlg<BigRational> blas = new BasicLinAlg<BigRational>();
610
611        List<GenVector<BigRational>> cokern = lu.nullSpaceBasis(A);
612        //System.out.println("cokern basis = " + cokern);
613        if (cokern.size() == 0) {
614            System.out.println("no cokern null space basis");
615            //return;
616        }
617        for (GenVector<BigRational> v : cokern) {
618            //System.out.println("v = " + v);
619            GenVector<BigRational> z = blas.leftProduct(v, Tp);
620            //System.out.println("z == 0: " + z.isZERO());
621            assertTrue("z == 0: " + z, z.isZERO());
622        }
623
624        List<GenVector<BigRational>> kern = lu.nullSpaceBasis(T);
625        //System.out.println("kern basis = " + kern);
626        if (kern.size() == 0) {
627            System.out.println("no kern null space basis");
628            //return;
629        }
630        for (GenVector<BigRational> v : kern) {
631            //System.out.println("v = " + v);
632            GenVector<BigRational> z = blas.rightProduct(v, Ap);
633            //System.out.println("z == 0: " + z.isZERO());
634            assertTrue("z == 0: " + z, z.isZERO());
635        }
636
637        // test ranks
638        long r1, r2, k, c;
639        //System.out.println("diag(Ap): " + Ap.getDiagonal());
640        //System.out.println("Ap: " + Ap);
641        r1 = lu.rankNS(Ap);
642        c = cokern.size();
643        assertTrue("0 <= rank < n: ", 0 <= r1 && r1 <= n);
644        assertTrue("rank + dim coker == n ", r1 + c == n);
645
646        //System.out.println("diag(Tp): " + Tp.getDiagonal());
647        //System.out.println("Tp: " + Tp);
648        r2 = lu.rankNS(Tp);
649        k = kern.size();
650        //System.out.println("rank A = " + r1 + ", c = " + c + ", n = " + n);
651        //System.out.println("rank T = " + r2 + ", k = " + k);
652        assertTrue("0 <= rank < n: ", 0 <= r2 && r2 <= n);
653        assertTrue("rank + dim ker == n ", r2 + k == n);
654    }
655
656
657    /**
658     * Test row echelon form and rank.
659     */
660    public void testRowEchelonForm() {
661        BigRational cfac = new BigRational(11);
662        int n = 50;
663        GenMatrixRing<BigRational> mfac = new GenMatrixRing<BigRational>(cfac, n, n);//rows, cols);
664        //System.out.println("mfac = " + mfac.toScript());
665        GenMatrixRing<BigRational> tfac = mfac.transpose();
666
667        GenMatrix<BigRational> A, Ap, App, B, T, Tpp;
668        A = mfac.random(kl, 2.0f / n);
669        //A = mfac.getONE();
670        //A = mfac.getZERO(); A.setMutate(3,4, cfac.parse("2")); A.setMutate(5,4, cfac.parse("3"));
671        if (n < 10)
672            System.out.println("A = " + A);
673        if (A.isZERO()) {
674            return;
675        }
676        assertTrue(" not isZERO( A )", !A.isZERO());
677        Ap = A.copy();
678        T = Ap.transpose(tfac);
679        //Tp = T.copy();
680        if (n < 10)
681            System.out.println("T = " + T.ring.rows);
682
683        LinAlg<BigRational> lu = new LinAlg<BigRational>();
684        //BasicLinAlg<BigRational> blas = new BasicLinAlg<BigRational>();
685
686        // test ranks
687        long r1 = 0, r2 = 0;
688        App = lu.rowEchelonForm(A);
689        //System.out.println("A:   " + Ap);
690        //System.out.println("App: " + App);
691        r1 = lu.rankRE(App);
692        //System.out.println("rank A = " + r1 + ", c = " + c + ", n = " + n);
693        assertTrue("0 <= rank < n: ", 0 <= r1 && r1 <= n);
694
695        Tpp = lu.rowEchelonForm(T);
696        //System.out.println("T:   " + T);
697        //System.out.println("Tpp: " + Tpp);
698        r2 = lu.rankRE(Tpp);
699        //System.out.println("rank A = " + r1 + ", c = " + c + ", n = " + n);
700        //System.out.println("rank T = " + r2 + ", k = " + k);
701        assertTrue("0 <= rank < n: ", 0 <= r2 && r2 <= n);
702        //assertTrue("rank == rank^t: ", r1 == r2);
703
704        // reduce upper triagonal part
705        //System.out.println("App: " + App);
706        B = lu.rowEchelonFormSparse(App);
707        //System.out.println("B:   " + B);
708        //System.out.println("B^2: " + B.power(2));
709        r2 = lu.rankRE(B);
710        assertTrue("rank1 == rank2: ", r1 == r2);
711    }
712
713
714    /**
715     * Test fraction free GE.
716     */
717    public void testFractionfreeGE() {
718        BigInteger cfac = new BigInteger(1);
719        int n = 4;
720        int m = 5;
721        GenMatrixRing<BigInteger> mfac = new GenMatrixRing<BigInteger>(cfac, n, m);//rows, cols);
722        //GenVectorModul<BigInteger> vfac = new GenVectorModul<BigInteger>(cfac, m);//rows);
723
724        GenMatrix<BigInteger> A, Ap, iA, AiA;
725        //A = mfac.random(kl, 0.7f);
726        A = mfac.parse("[ [3,4,-2,1,-2], [1,-1,2,2,7], [4,-3,4,-3,2], [-1,1,6,-1,1] ]");
727        //System.out.println("A = " + A);
728        if (A.isZERO()) {
729            return;
730        }
731        assertTrue(" not isZERO( A )", !A.isZERO());
732        Ap = A.copy();
733
734        LinAlg<BigInteger> lu = new LinAlg<BigInteger>();
735        BasicLinAlg<BigInteger> blas = new BasicLinAlg<BigInteger>();
736
737        List<Integer> P = lu.fractionfreeGaussElimination(A);
738        //System.out.println("P = " + P);
739        if (P.size() == 0) {
740            //System.out.println("undecomposable");
741            return;
742        }
743        assertTrue("#P != 0: ", P.size() > 0);
744        //System.out.println("A = " + A);
745
746        n = 10;
747        m = n;
748        mfac = new GenMatrixRing<BigInteger>(cfac, n, m);//rows, cols);
749
750        A = mfac.random(5, 0.67f);
751        //System.out.println("A = " + A);
752        if (A.isZERO()) {
753            return;
754        }
755        assertTrue(" not isZERO( A )", !A.isZERO());
756        Ap = A.copy();
757
758        P = lu.fractionfreeGaussElimination(A);
759        //System.out.println("P = " + P);
760        if (P.size() == 0) {
761            //System.out.println("undecomposable");
762            return;
763        }
764        assertTrue("#P != 0: ", P.size() > 0);
765        //System.out.println("A = " + A);
766    }
767
768
769    /**
770     * Test fraction free GE polynomial.
771     */
772    public void testFractionfreeGEpoly() {
773        BigRational cfac = new BigRational(1);
774        int n = 4;
775        int m = n;
776        String[] vars = new String[]{ "a1", "a2", "a3", "a4" };
777        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, vars);
778        GenMatrixRing<GenPolynomial<BigRational>> mfac = new GenMatrixRing<GenPolynomial<BigRational>>(pfac, n, m);
779
780        GenMatrix<GenPolynomial<BigRational>> A, Ap, iA, AiA;
781        A = mfac.random(4, 0.5f);
782        //A = mfac.parse("[ [3,4,-2,1,-2], [1,-1,2,2,7], [4,-3,4,-3,2], [-1,1,6,-1,1] ]");
783        //System.out.println("A = " + A);
784        if (A.isZERO()) {
785            return;
786        }
787        assertTrue(" not isZERO( A )", !A.isZERO());
788        Ap = A.copy();
789
790        LinAlg<GenPolynomial<BigRational>> lu = new LinAlg<GenPolynomial<BigRational>>();
791
792        List<Integer> P = lu.fractionfreeGaussElimination(A);
793        //System.out.println("P = " + P);
794        if (P.size() == 0) {
795            //System.out.println("undecomposable");
796            return;
797        }
798        assertTrue("#P != 0: ", P.size() > 0);
799        //System.out.println("A = " + A);
800
801
802        vars = new String[]{ "a11", "a12", "a13", "a14", "a21", "a22", "a23", "a24", "a31", "a32", "a33", "a34", "a41", "a42", "a43", "a44" };
803        pfac = new GenPolynomialRing<BigRational>(cfac, vars);
804        mfac = new GenMatrixRing<GenPolynomial<BigRational>>(pfac, n, m);
805        A = mfac.parse("[ [a11, a12, a13, a14], [a21, a22, a23, a24], [a31, a32, a33, a34], [a41, a42, a43, a44]] ");
806        //System.out.println("A = " + A);
807        if (A.isZERO()) {
808            return;
809        }
810        assertTrue(" not isZERO( A )", !A.isZERO());
811        Ap = A.copy();
812
813        P = lu.fractionfreeGaussElimination(A);
814        //System.out.println("P = " + P);
815        if (P.size() == 0) {
816            //System.out.println("undecomposable");
817            return;
818        }
819        assertTrue("#P != 0: ", P.size() > 0);
820        //System.out.println("A = " + A);
821
822        FactorAbstract<BigRational> ufd = FactorFactory.getImplementation(cfac);
823        int i = 0;
824        for (ArrayList<GenPolynomial<BigRational>> row : A.matrix) {
825             int j = 0;
826             for (GenPolynomial<BigRational> elem : row) {
827                 if (elem.isZERO()) {
828                     j++;
829                     continue;
830                 }
831                 SortedMap<GenPolynomial<BigRational>, Long> pf = ufd.factors(elem);
832                 //System.out.println("A(" + i + "," + j + ") = " + elem);
833                 //System.out.println("factors = " + pf);
834                 assertTrue("#factors == 1:", pf.size() == 1);
835                 j++;
836             }
837             i++;
838        }
839        ComputerThreads.terminate();
840    }
841
842}