001/*
002 * $Id: ExpVectorTest.java 5905 2018-08-24 10:23:58Z kredel $
003 */
004
005package edu.jas.poly;
006
007
008import java.util.ArrayList;
009import java.util.Arrays;
010import java.util.List;
011
012import junit.framework.Test;
013import junit.framework.TestCase;
014import junit.framework.TestSuite;
015
016
017import edu.jas.arith.BigInteger;
018
019
020/**
021 * ExpVector tests with JUnit. Tests arithmetic operations, for comparison tests
022 * see TermOrderTest.
023 * @author Heinz Kredel
024 */
025
026public class ExpVectorTest extends TestCase {
027
028
029    /**
030     * main
031     */
032    public static void main(String[] args) {
033        junit.textui.TestRunner.run(suite());
034    }
035
036
037    /**
038     * Constructs a <CODE>ExpVectorTest</CODE> object.
039     * @param name String.
040     */
041    public ExpVectorTest(String name) {
042        super(name);
043    }
044
045
046    /**
047     */
048    public static Test suite() {
049        TestSuite suite = new TestSuite(ExpVectorTest.class);
050        return suite;
051    }
052
053
054    ExpVector a, b, c, d;
055
056
057    @Override
058    protected void setUp() {
059        a = b = c = d = null;
060    }
061
062
063    @Override
064    protected void tearDown() {
065        a = b = c = d = null;
066    }
067
068
069    /**
070     * Test constructor and toString.
071     */
072    public void testConstructor() {
073        a = ExpVector.create(0);
074        b = ExpVector.create(0);
075        assertEquals("() = ()", a, b);
076        assertEquals("length( () ) = 0", a.length(), 0);
077        assertTrue("isZERO( () )", a.isZERO());
078
079        a = ExpVector.create(10);
080        b = ExpVector.create(10);
081        assertEquals("10e = 10e", a, b);
082        assertEquals("length( 10e ) = 10", a.length(), 10);
083        assertTrue("isZERO( ( 10e ) )", a.isZERO());
084
085        String s = "(0,0,0,0,0,0,0,0,0,0)";
086        a = ExpVector.create(s);
087        String t = a.toString().substring(0, s.length());
088
089        assertEquals("stringConstr = toString", s, t);
090        assertTrue("isZERO( ( 10e ) )", a.isZERO());
091    }
092
093
094    /**
095     * Test bitLength.
096     */
097    public void testBitLength() {
098        a = ExpVector.create(0);
099        assertEquals("blen(0) = 0", 0, a.bitLength());
100
101        b = ExpVector.create(10);
102        assertEquals("blen(0) = 10", 10, b.bitLength());
103
104        c = ExpVector.random(10, 20, 0.5f);
105        //System.out.println("c = " + c);
106        //System.out.println("blen(c) = " + c.bitLength());
107        assertTrue("blen(random) >= 0", 0 <= c.bitLength());
108    }
109
110
111    /**
112     * Test random integer.
113     */
114    public void testRandom() {
115        float q = (float) 0.3;
116
117        a = ExpVector.random(5, 10, q);
118        String s = a.toString();
119        if (s.indexOf(":") >= 0) {
120            s = s.substring(0, s.indexOf(":"));
121        }
122        b = ExpVector.create(s);
123
124        assertEquals("a == b", true, a.equals(b));
125
126        c = ExpVector.EVDIF(b, a);
127
128        assertTrue("a-b = 0", c.isZERO());
129    }
130
131
132    /**
133     * Test addition.
134     */
135    public void testAddition() {
136        float q = (float) 0.2;
137
138        a = ExpVector.random(5, 10, q);
139
140        b = ExpVector.EVSUM(a, a);
141        c = ExpVector.EVDIF(b, a);
142
143        assertEquals("a+a-a = a", c, a);
144        assertTrue("a+a-a = a", c.equals(a));
145
146        boolean t;
147        t = ExpVector.EVMT(b, a);
148        assertTrue("a | a+a", t);
149
150        a = ExpVector.random(5, 10, q);
151        b = ExpVector.random(5, 10, q);
152
153        c = ExpVector.EVSUM(a, b);
154        d = ExpVector.EVSUM(b, a);
155        assertTrue("a+b = b+a", c.equals(d));
156    }
157
158
159    /**
160     * Test lcm.
161     */
162    public void testLcm() {
163        float q = (float) 0.2;
164
165        a = ExpVector.random(5, 10, q);
166        b = ExpVector.random(5, 10, q);
167        c = ExpVector.EVLCM(a, b);
168        d = ExpVector.EVLCM(b, a);
169
170        assertTrue("lcm(a,b) = lcm(b,a)", c.equals(d));
171
172        assertTrue("a | lcm(a,b)", ExpVector.EVMT(c, a));
173        assertTrue("b | lcm(a,b)", ExpVector.EVMT(c, b));
174
175        d = ExpVector.EVDIF(c, a);
176        assertTrue("sign(lcm(a,b)-a) >= 0", ExpVector.EVSIGN(d) >= 0);
177        d = ExpVector.EVDIF(c, b);
178        assertTrue("sign(lcm(a,b)-b) >= 0", ExpVector.EVSIGN(d) >= 0);
179    }
180
181
182    /**
183     * Test tdeg.
184     */
185    public void testTdeg() {
186        a = ExpVector.create(100);
187        assertTrue("tdeg(a) = 0", ExpVector.EVTDEG(a) == 0);
188
189        float q = (float) 0.2;
190
191        a = ExpVector.random(5, 10, q);
192        b = ExpVector.random(5, 10, q);
193
194        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
195        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
196
197        c = ExpVector.EVSUM(a, b);
198        assertTrue("tdeg(a+b) >= tdeg(a)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(a));
199        assertTrue("tdeg(a+b) >= tdeg(b)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(b));
200
201        c = ExpVector.EVLCM(a, b);
202        assertTrue("tdeg(lcm(a,b)) >= tdeg(a)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(a));
203        assertTrue("tdeg(lcm(a,b)) >= tdeg(b)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(b));
204    }
205
206
207    /**
208     * Test weighted.
209     */
210    public void testWeightdeg() {
211        a = ExpVector.create(100);
212        assertTrue("tdeg(a) = 0", ExpVector.EVTDEG(a) == 0);
213        assertTrue("wdeg(a) = 0", ExpVector.EVWDEG(null, a) == 0);
214
215        float q = (float) 0.2;
216
217        a = ExpVector.random(5, 10, q);
218        b = ExpVector.random(5, 10, q);
219        long[][] w = new long[][] { new long[] { 1l, 1l, 1l, 1l, 1l } };
220
221        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
222        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
223
224        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
225        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
226
227        assertEquals("tdeg(a) == wdeg(a)", ExpVector.EVTDEG(a), ExpVector.EVWDEG(w, a));
228        assertEquals("tdeg(b) == wdeg(b)", ExpVector.EVTDEG(b), ExpVector.EVWDEG(w, b));
229
230        c = ExpVector.EVSUM(a, b);
231        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
232        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
233
234        c = ExpVector.EVLCM(a, b);
235        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
236        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
237
238
239        w = new long[][] { new long[] { 10l, 1l, 3l, 9l, 100l } };
240
241        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
242        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
243
244        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
245        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
246
247        assertTrue("tdeg(a) <= wdeg(a)", ExpVector.EVTDEG(a) <= ExpVector.EVWDEG(w, a));
248        assertTrue("tdeg(b) <= wdeg(b)", ExpVector.EVTDEG(b) <= ExpVector.EVWDEG(w, b));
249
250        c = ExpVector.EVSUM(a, b);
251        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
252        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
253
254        c = ExpVector.EVLCM(a, b);
255        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
256        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
257
258
259        w = new long[][] { new long[] { 10l, 1l, 3l, 9l, 100l }, new long[] { 1l, 1l, 1l, 1l, 1l } };
260
261        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
262        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
263
264        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
265        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
266
267        assertTrue("tdeg(a) <= wdeg(a)", ExpVector.EVTDEG(a) <= ExpVector.EVWDEG(w, a));
268        assertTrue("tdeg(b) <= wdeg(b)", ExpVector.EVTDEG(b) <= ExpVector.EVWDEG(w, b));
269
270        c = ExpVector.EVSUM(a, b);
271        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
272        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
273
274        c = ExpVector.EVLCM(a, b);
275        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
276        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
277
278    }
279
280
281    /**
282     * Test dependency on variables.
283     */
284    public void testDependency() {
285        int[] exp;
286        int[] dep;
287
288        a = ExpVector.create(10, 5, 2l);
289        exp = new int[] { 5 };
290        dep = ExpVector.EVDOV(a);
291        assertTrue("[5] = [5]", Arrays.equals(exp, dep));
292
293        b = ExpVector.create(10, 3, 9l);
294        exp = new int[] { 3 };
295        dep = ExpVector.EVDOV(b);
296        assertTrue("[3] = [3]", Arrays.equals(exp, dep));
297
298        c = ExpVector.EVSUM(a, b);
299        exp = new int[] { 3, 5 };
300        dep = ExpVector.EVDOV(c);
301        assertTrue("[3,5] = [3,5] " + Arrays.toString(exp) + "," + Arrays.toString(dep),
302                        Arrays.equals(exp, dep));
303
304        b = ExpVector.create(10);
305        exp = new int[] {};
306        dep = ExpVector.EVDOV(b);
307        assertTrue("[] = []", Arrays.equals(exp, dep));
308
309        b = ExpVector.create(0);
310        exp = new int[] {};
311        dep = ExpVector.EVDOV(b);
312        assertTrue("[] = []", Arrays.equals(exp, dep));
313
314        b = ExpVector.create(1, 0, 1l);
315        exp = new int[] { 0 };
316        dep = ExpVector.EVDOV(b);
317        assertTrue("[0] = [0]", Arrays.equals(exp, dep));
318    }
319
320
321    /**
322     * Test random exp vector 2.
323     */
324    public void testRandom2() {
325        float q = (float) 0.2;
326
327        a = ExpVector.random(5, 10, q);
328        b = ExpVector.create("" + a);
329
330        assertEquals("a == b", true, a.equals(b));
331
332        c = b.subtract(a);
333
334        assertTrue("a-b = 0", c.isZERO());
335    }
336
337
338    /**
339     * Test addition.
340     */
341    public void testAddition2() {
342        float q = (float) 0.2;
343
344        a = ExpVector.random(5, 10, q);
345
346        b = a.sum(a);
347        c = b.subtract(a);
348
349        assertEquals("a+a-a = a", c, a);
350        assertTrue("a+a-a = a", c.equals(a));
351
352        boolean t;
353        t = b.multipleOf(a);
354        assertTrue("a | a+a", t);
355
356        a = ExpVector.random(5, 10, q);
357        b = ExpVector.random(5, 10, q);
358
359        c = a.sum(b);
360        d = b.sum(a);
361        assertTrue("a+b = b+a", c.equals(d));
362    }
363
364
365    /**
366     * Test lcm.
367     */
368    public void testLcm2() {
369        float q = (float) 0.2;
370
371        a = ExpVector.random(5, 10, q);
372        b = ExpVector.random(5, 10, q);
373        c = a.lcm(b);
374        d = b.lcm(a);
375
376        assertTrue("lcm(a,b) = lcm(b,a)", c.equals(d));
377
378        assertTrue("a | lcm(a,b)", c.multipleOf(a));
379        assertTrue("b | lcm(a,b)", c.multipleOf(b));
380
381        d = c.subtract(a);
382        assertTrue("sign(lcm(a,b)-a) >= 0", d.signum() >= 0);
383        d = c.subtract(b);
384        assertTrue("sign(lcm(a,b)-b) >= 0", d.signum() >= 0);
385    }
386
387
388    /**
389     * Test tdeg.
390     */
391    public void testTdeg2() {
392        a = ExpVector.create(100);
393        assertTrue("tdeg(a) = 0", ExpVector.EVTDEG(a) == 0);
394
395        float q = (float) 0.2;
396
397        a = ExpVector.random(5, 10, q);
398        b = ExpVector.random(5, 10, q);
399
400        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
401        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
402
403        c = a.sum(b);
404        assertTrue("tdeg(a+b) >= tdeg(a)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(a));
405        assertTrue("tdeg(a+b) >= tdeg(b)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(b));
406
407        c = a.lcm(b);
408        assertTrue("tdeg(lcm(a,b)) >= tdeg(a)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(a));
409        assertTrue("tdeg(lcm(a,b)) >= tdeg(b)", ExpVector.EVTDEG(c) >= ExpVector.EVTDEG(b));
410    }
411
412
413    /**
414     * Test weighted.
415     */
416    public void testWeightdeg2() {
417        a = ExpVector.create(100);
418        assertTrue("tdeg(a) = 0", ExpVector.EVTDEG(a) == 0);
419        assertTrue("wdeg(a) = 0", ExpVector.EVWDEG(null, a) == 0);
420
421        float q = (float) 0.2;
422
423        a = ExpVector.random(5, 10, q);
424        b = ExpVector.random(5, 10, q);
425        long[][] w = new long[][] { new long[] { 1l, 1l, 1l, 1l, 1l } };
426
427        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
428        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
429
430        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
431        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
432
433        assertEquals("tdeg(a) == wdeg(a)", ExpVector.EVTDEG(a), ExpVector.EVWDEG(w, a));
434        assertEquals("tdeg(b) == wdeg(b)", ExpVector.EVTDEG(b), ExpVector.EVWDEG(w, b));
435
436        c = a.sum(b);
437        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
438        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
439
440        c = a.lcm(b);
441        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
442        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
443
444
445        w = new long[][] { new long[] { 10l, 1l, 3l, 9l, 100l } };
446
447        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
448        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
449
450        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
451        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
452
453        assertTrue("tdeg(a) <= wdeg(a)", ExpVector.EVTDEG(a) <= ExpVector.EVWDEG(w, a));
454        assertTrue("tdeg(b) <= wdeg(b)", ExpVector.EVTDEG(b) <= ExpVector.EVWDEG(w, b));
455
456        c = a.sum(b);
457        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
458        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
459
460        c = a.lcm(b);
461        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
462        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
463
464
465        w = new long[][] { new long[] { 10l, 1l, 3l, 9l, 100l }, new long[] { 1l, 1l, 1l, 1l, 1l } };
466
467        assertTrue("tdeg(a) >= 0", ExpVector.EVTDEG(a) >= 0);
468        assertTrue("tdeg(b) >= 0", ExpVector.EVTDEG(b) >= 0);
469
470        assertTrue("wdeg(a) >= 0", ExpVector.EVWDEG(w, a) >= 0);
471        assertTrue("wdeg(b) >= 0", ExpVector.EVWDEG(w, b) >= 0);
472
473        assertTrue("tdeg(a) <= wdeg(a)", ExpVector.EVTDEG(a) <= ExpVector.EVWDEG(w, a));
474        assertTrue("tdeg(b) <= wdeg(b)", ExpVector.EVTDEG(b) <= ExpVector.EVWDEG(w, b));
475
476        c = a.sum(b);
477        assertTrue("wdeg(a+b) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
478        assertTrue("wdeg(a+b) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
479
480        c = a.lcm(b);
481        assertTrue("wdeg(lcm(a,b)) >= wdeg(a)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, a));
482        assertTrue("wdeg(lcm(a,b)) >= wdeg(b)", ExpVector.EVWDEG(w, c) >= ExpVector.EVWDEG(w, b));
483
484    }
485
486
487    /**
488     * Test dependency on variables.
489     */
490    public void testDependency2() {
491        int[] exp;
492        int[] dep;
493
494        a = ExpVector.create(10, 5, 2l);
495        exp = new int[] { 5 };
496        dep = a.dependencyOnVariables();
497        assertTrue("[5] = [5]", Arrays.equals(exp, dep));
498
499        b = ExpVector.create(10, 3, 9l);
500        exp = new int[] { 3 };
501        dep = b.dependencyOnVariables();
502        assertTrue("[3] = [3]", Arrays.equals(exp, dep));
503
504        c = a.sum(b);
505        exp = new int[] { 3, 5 };
506        dep = c.dependencyOnVariables();
507        assertTrue("[3,5] = [3,5] " + Arrays.toString(exp) + "," + Arrays.toString(dep),
508                        Arrays.equals(exp, dep));
509
510        b = ExpVector.create(10);
511        exp = new int[] {};
512        dep = b.dependencyOnVariables();
513        assertTrue("[] = []", Arrays.equals(exp, dep));
514
515        b = ExpVector.create(0);
516        exp = new int[] {};
517        dep = b.dependencyOnVariables();
518        assertTrue("[] = []", Arrays.equals(exp, dep));
519
520        b = ExpVector.create(1, 0, 1l);
521        exp = new int[] { 0 };
522        dep = b.dependencyOnVariables();
523        assertTrue("[0] = [0]", Arrays.equals(exp, dep));
524    }
525
526
527    /**
528     * Test evaluation.
529     */
530    public void testEvaluation() {
531        float q = (float) 0.2;
532        int rl = 5;
533
534        a = ExpVector.random(rl, 10, q);
535        b = ExpVector.random(rl, 10, q);
536        BigInteger fv = new BigInteger(0);
537        List<BigInteger> v = new ArrayList<BigInteger>(a.length());
538        for (int i = 0; i < a.length(); i++) {
539            v.add(fv.random(4));
540        }
541
542        BigInteger av = a.evaluate(fv, v);
543        BigInteger bv = b.evaluate(fv, v);
544
545        c = a.sum(b);
546        BigInteger cv = c.evaluate(fv, v);
547        BigInteger dv = av.multiply(bv);
548
549        assertEquals("a(v)*b(v) = (a+b)(v) ", cv, dv);
550
551        c = ExpVector.create(rl);
552        cv = c.evaluate(fv, v);
553        dv = fv.getONE();
554        assertEquals("0(v) = 1 ", cv, dv);
555
556        v.clear();
557        for (int i = 0; i < a.length(); i++) {
558            v.add(fv.getZERO());
559        }
560        cv = c.evaluate(fv, v);
561        dv = fv.getONE();
562        assertEquals("0(0) = 1 ", cv, dv);
563
564        av = a.evaluate(fv, v);
565        if (a.isZERO()) {
566            dv = fv.getONE();
567            assertEquals("0(0) = 1 ", av, dv);
568        } else {
569            dv = fv.getZERO();
570            assertEquals("a(0) = 0 ", av, dv);
571        }
572    }
573
574}