Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.poly;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.Map;
011
012import edu.jas.arith.BigComplex;
013import edu.jas.arith.BigQuaternion;
014import edu.jas.arith.BigQuaternionRing;
015import edu.jas.arith.BigRational;
016import edu.jas.structure.RingElem;
017
018import junit.framework.Test;
019import junit.framework.TestCase;
020import junit.framework.TestSuite;
021
022
023/**
024 * GenSolvablePolynomial Test using JUnit. <b>Note:</b> not optimal since
025 * GenSolvablePolynomial does not implement
026 * RingElem&lt;GenSolvablePolynomial&gt;
027 * @author Heinz Kredel
028 */
029
030public class GenSolvablePolynomialTest extends TestCase {
031
032
033    /**
034     * main
035     */
036    public static void main(String[] args) {
037        junit.textui.TestRunner.run(suite());
038    }
039
040
041    /**
042     * Constructs a <CODE>GenSolvablePolynomialTest</CODE> object.
043     * @param name String.
044     */
045    public GenSolvablePolynomialTest(String name) {
046        super(name);
047    }
048
049
050    /**
051     * suite.
052     */
053    public static Test suite() {
054        TestSuite suite = new TestSuite(GenSolvablePolynomialTest.class);
055        return suite;
056    }
057
058
059    int rl = 6; // even for Weyl
060
061
062    int kl = 10;
063
064
065    int ll = 7;
066
067
068    int el = 4;
069
070
071    float q = 0.5f;
072
073    @Override
074    protected void setUp() {
075        // a = b = c = d = e = null;
076    }
077
078
079    @Override
080    protected void tearDown() {
081        // a = b = c = d = e = null;
082    }
083
084
085    /**
086     * Test constructors and factory.
087     */
088    public void testConstructors() {
089        // rational numbers
090        BigRational rf = new BigRational();
091        // System.out.println("rf = " + rf);
092
093        //BigRational r = rf.fromInteger( 99 );
094        // System.out.println("r = " + r);
095        //r = rf.random( 9 );
096        // System.out.println("r = " + r);
097
098        // polynomials over rational numbers
099        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(rf, 2);
100        // System.out.println("pf = " + pf);
101
102        GenSolvablePolynomial<BigRational> p = pf.getONE();
103        // System.out.println("p = " + p);
104        p = pf.random(9);
105        // System.out.println("p = " + p);
106        p = pf.getZERO();
107        // System.out.println("p = " + p);
108
109        RingElem<GenPolynomial<BigRational>> pe = new GenSolvablePolynomial<BigRational>(pf);
110        //System.out.println("pe = " + pe);
111        //System.out.println("p.equals(pe) = " + p.equals(pe) );
112        //System.out.println("p.equals(p) = " + p.equals(p) );
113        assertTrue("p.equals(pe) = ", p.equals(pe));
114        assertTrue("p.equals(p) = ", p.equals(p));
115
116        pe = pe.sum(p); // why not p = p.add(pe) ?
117        //System.out.println("pe = " + pe);
118        assertTrue("pe.isZERO() = ", pe.isZERO());
119        p = pf.random(9);
120        p = (GenSolvablePolynomial<BigRational>) p.subtract(p);
121        //System.out.println("p = " + p);
122        //System.out.println("p.isZERO() = " + p.isZERO());
123        assertTrue("p.isZERO() = ", p.isZERO());
124
125
126        // polynomials over (polynomials over rational numbers)
127        GenSolvablePolynomialRing<GenPolynomial<BigRational>> ppf = new GenSolvablePolynomialRing<GenPolynomial<BigRational>>(
128                        pf, 3);
129        // System.out.println("ppf = " + ppf);
130
131        GenSolvablePolynomial<GenPolynomial<BigRational>> pp = ppf.getONE();
132        // System.out.println("pp = " + pp);
133        pp = ppf.random(2);
134        // System.out.println("pp = " + pp);
135        pp = ppf.getZERO();
136        // System.out.println("pp = " + pp);
137
138        RingElem<GenPolynomial<GenPolynomial<BigRational>>> ppe = new GenSolvablePolynomial<GenPolynomial<BigRational>>(
139                        ppf);
140        // System.out.println("ppe = " + ppe);
141        // System.out.println("pp.equals(ppe) = " + pp.equals(ppe) );
142        // System.out.println("pp.equals(pp) = " + pp.equals(pp) );
143        assertTrue("pp.equals(ppe) = ", pp.equals(ppe));
144        assertTrue("pp.equals(pp) = ", pp.equals(pp));
145
146        ppe = ppe.sum(pp); // why not pp = pp.add(ppe) ?
147        //System.out.println("ppe = " + ppe);
148        assertTrue("ppe.isZERO() = ", ppe.isZERO());
149        pp = ppf.random(2);
150        pp = (GenSolvablePolynomial<GenPolynomial<BigRational>>) pp.subtract(pp);
151        //System.out.println("pp = " + pp);
152        //System.out.println("pp.isZERO() = " + pp.isZERO());
153        assertTrue("pp.isZERO() = ", pp.isZERO());
154
155
156        // polynomials over (polynomials over (polynomials over rational numbers))
157        GenSolvablePolynomialRing<GenPolynomial<GenPolynomial<BigRational>>> pppf = new GenSolvablePolynomialRing<GenPolynomial<GenPolynomial<BigRational>>>(
158                        ppf, 4);
159        // System.out.println("pppf = " + pppf);
160
161        GenSolvablePolynomial<GenPolynomial<GenPolynomial<BigRational>>> ppp = pppf.getONE();
162        //System.out.println("ppp = " + ppp);
163        ppp = pppf.random(2);
164        // System.out.println("ppp = " + ppp);
165        ppp = pppf.getZERO();
166        // System.out.println("ppp = " + ppp);
167
168        RingElem<GenPolynomial<GenPolynomial<GenPolynomial<BigRational>>>> pppe = new GenSolvablePolynomial<GenPolynomial<GenPolynomial<BigRational>>>(
169                        pppf);
170        // System.out.println("pppe = " + pppe);
171        // System.out.println("ppp.equals(pppe) = " + ppp.equals(pppe) );
172        // System.out.println("ppp.equals(ppp) = " + ppp.equals(ppp) );
173        assertTrue("ppp.equals(pppe) = ", ppp.equals(pppe));
174        assertTrue("ppp.equals(ppp) = ", ppp.equals(ppp));
175
176        pppe = pppe.sum(ppp); // why not ppp = ppp.add(pppe) ?
177        // System.out.println("pppe = " + pppe);
178        assertTrue("pppe.isZERO() = ", pppe.isZERO());
179        ppp = pppf.random(2);
180        ppp = (GenSolvablePolynomial<GenPolynomial<GenPolynomial<BigRational>>>) ppp.subtract(ppp);
181        // System.out.println("ppp = " + ppp);
182        // System.out.println("ppp.isZERO() = " + ppp.isZERO());
183        assertTrue("ppp.isZERO() = ", ppp.isZERO());
184    }
185
186
187    /**
188     * Test extension and contraction.
189     */
190    public void testExtendContract() {
191        // rational numbers
192        BigRational cf = new BigRational(99);
193        // System.out.println("cf = " + cf);
194
195        // polynomials over rational numbers
196        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf, rl);
197        // System.out.println("pf = " + pf);
198
199        GenSolvablePolynomial<BigRational> a = pf.random(kl, ll, el, q);
200        //System.out.println("a = " + a);
201
202        int k = rl;
203        GenSolvablePolynomialRing<BigRational> pfe = pf.extend(k);
204        GenSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
205        assertEquals("pf == pfec", pf, pfec);
206
207        GenSolvablePolynomial<BigRational> ae = (GenSolvablePolynomial<BigRational>) a.extend(pfe, 0, 0);
208
209        Map<ExpVector, GenPolynomial<BigRational>> m = ae.contract(pfec);
210        List<GenPolynomial<BigRational>> ml = new ArrayList<GenPolynomial<BigRational>>(m.values());
211        GenSolvablePolynomial<BigRational> aec = (GenSolvablePolynomial<BigRational>) ml.get(0);
212        assertEquals("a == aec", a, aec);
213        //System.out.println("ae = " + ae);
214        //System.out.println("aec = " + aec);
215    }
216
217
218    /**
219     * Test extension and contraction for Weyl relations.
220     */
221    public void testExtendContractWeyl() {
222        // rational numbers
223        BigRational cf = new BigRational(99);
224        // System.out.println("cf = " + cf);
225
226        // polynomials over rational numbers
227        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf, rl);
228        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
229        //wl.generate(pf);
230        pf.addRelations(wl);
231        // System.out.println("pf = " + pf);
232
233        GenSolvablePolynomial<BigRational> a = pf.random(kl, ll, el, q);
234        //System.out.println("a = " + a);
235
236        int k = rl;
237        GenSolvablePolynomialRing<BigRational> pfe = pf.extend(k);
238        GenSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
239        assertEquals("pf == pfec", pf, pfec);
240
241        GenSolvablePolynomial<BigRational> ae = (GenSolvablePolynomial<BigRational>) a.extend(pfe, 0, 0);
242
243        Map<ExpVector, GenPolynomial<BigRational>> m = ae.contract(pfec);
244        List<GenPolynomial<BigRational>> ml = new ArrayList<GenPolynomial<BigRational>>(m.values());
245        GenSolvablePolynomial<BigRational> aec = (GenSolvablePolynomial<BigRational>) ml.get(0);
246        assertEquals("a == aec", a, aec);
247        //System.out.println("ae = " + ae);
248        //System.out.println("aec = " + aec);
249    }
250
251
252    /**
253     * Test reversion with rational coefficients.
254     */
255    public void testReverse() {
256        // rational numbers
257        BigRational cf = new BigRational(99);
258        // System.out.println("cf = " + cf);
259        String[] vars = new String[] { "x1", "x2", "x3", "x4", "x5", "x6" };
260
261        // polynomials over rational numbers
262        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf, vars);
263        //System.out.println("pf = " + pf.toScript());
264
265        GenSolvablePolynomial<BigRational> a, b, c, d;
266        a = pf.random(kl, ll, el, q);
267        //System.out.println("a = " + a);
268
269        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
270        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
271        assertEquals("pf == pfrr", pf, pfrr);
272        //System.out.println("pfr = " + pfr);
273
274        GenSolvablePolynomial<BigRational> ar, br, cr;
275        ar = (GenSolvablePolynomial<BigRational>) a.reverse(pfr);
276        GenSolvablePolynomial<BigRational> arr = (GenSolvablePolynomial<BigRational>) ar.reverse(pfrr);
277        assertEquals("a == arr", a, arr);
278        //System.out.println("ar = " + ar);
279        //System.out.println("arr = " + arr);
280
281        b = pf.random(kl, ll, el, q);
282        //System.out.println("b = " + b);
283        br = (GenSolvablePolynomial<BigRational>) b.reverse(pfr);
284        //System.out.println("br = " + br);
285
286        c = b.multiply(a);
287        cr = ar.multiply(br);
288        //System.out.println("cr = " + cr);
289
290        d = (GenSolvablePolynomial<BigRational>) cr.reverse(pfrr);
291        //System.out.println("d = " + d);
292        assertEquals("b*a == rev(a)*rev(b): ", c, d);
293    }
294
295
296    /**
297     * Test reversion for Weyl relations.
298     */
299    public void testReverseWeyl() {
300        // rational numbers
301        BigRational cf = new BigRational(99);
302        // System.out.println("cf = " + cf);
303        String[] vars = new String[] { "x1", "x2", "x3", "x4", "x5", "x6" };
304
305        // polynomials over rational numbers
306        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf, vars);
307        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
308        wl.generate(pf);
309        //System.out.println("pf = " + pf.toScript());
310
311        GenSolvablePolynomial<BigRational> a, b, c, d;
312        a = pf.random(kl, ll, el, q);
313        //System.out.println("a = " + a);
314
315        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
316        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
317        assertEquals("pf == pfrr", pf, pfrr);
318        //System.out.println("pfr = " + pfr);
319
320        GenSolvablePolynomial<BigRational> ar, br, cr;
321        ar = (GenSolvablePolynomial<BigRational>) a.reverse(pfr);
322        GenSolvablePolynomial<BigRational> arr = (GenSolvablePolynomial<BigRational>) ar.reverse(pfrr);
323        assertEquals("a == arr", a, arr);
324        //System.out.println("ar = " + ar);
325        //System.out.println("arr = " + arr);
326
327        b = pf.random(kl, ll, el, q);
328        //System.out.println("b = " + b);
329        br = (GenSolvablePolynomial<BigRational>) b.reverse(pfr);
330        //System.out.println("br = " + br);
331
332        c = b.multiply(a);
333        cr = ar.multiply(br);
334        //System.out.println("cr = " + cr);
335
336        d = (GenSolvablePolynomial<BigRational>) cr.reverse(pfrr);
337        //System.out.println("d = " + d);
338        assertEquals("rev(b*a) == rev(a)*rev(b): ", c, d);
339    }
340
341
342    /**
343     * Test recursion.
344     */
345    public void testRecursion() {
346        // rational numbers
347        BigRational rf = new BigRational();
348        // System.out.println("rf = " + rf);
349
350        String[] vars = new String[] { "a", "b", "c", "d" };
351        TermOrder to = new TermOrder(TermOrder.INVLEX);
352        // polynomials over rational numbers
353        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(rf, 4, to,
354                        vars);
355        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
356        //wl.generate(pf);
357        pf.addRelations(wl);
358        //System.out.println("pf = " + pf);
359
360        GenSolvablePolynomial<BigRational> sp = pf.random(5);
361        //System.out.println("sp = " + sp);
362        sp = (GenSolvablePolynomial<BigRational>) sp.subtract(sp);
363        assertTrue("sp == 0 ", sp.isZERO());
364
365        // polynomials over (solvable) polynomials over rational numbers
366        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rpf = new GenSolvablePolynomialRing<GenPolynomial<BigRational>>(
367                        pf, 2);
368        RelationGenerator<GenPolynomial<BigRational>> rwl = new WeylRelations<GenPolynomial<BigRational>>();
369        //rwl.generate(rpf);
370        rpf.addRelations(rwl);
371        //System.out.println("rpf = " + rpf);
372
373        GenSolvablePolynomial<GenPolynomial<BigRational>> rsp = rpf.random(5);
374        //System.out.println("rsp = " + rsp);
375        rsp = (GenSolvablePolynomial<GenPolynomial<BigRational>>) rsp.subtract(rsp);
376        assertTrue("rsp == 0 ", rsp.isZERO());
377    }
378
379
380    /**
381     * Test reversion with quaternion coefficients.
382     */
383    public void testReverseQuat() {
384        // quaternion numbers
385        BigQuaternionRing cf = new BigQuaternionRing();
386        // System.out.println("cf = " + cf);
387        String[] vars = new String[] { "x1", "x2", "x3", "x4" };
388
389        // polynomials over quaternion numbers
390        GenSolvablePolynomialRing<BigQuaternion> pf = new GenSolvablePolynomialRing<BigQuaternion>(cf, vars);
391        //System.out.println("pf = " + pf.toScript());
392        GenSolvablePolynomialRing<BigQuaternion> pfr;
393        try {
394            pfr = pf.reverse();
395            assertFalse("pf coefficents commuative: " + pf, pf.coFac.isCommutative());
396        } catch (IllegalArgumentException e) {
397            assertTrue("pf coefficents commuative: " + pf, pf.coFac.isCommutative());
398            pfr = null;
399        }
400        //System.out.println("pf = " + pf.toScript());
401        //System.out.println("pfr = " + pfr.toScript());
402        GenSolvablePolynomialRing<BigQuaternion> pfrr = pfr.reverse();
403        assertEquals("pf == pfrr", pf, pfrr);
404
405        // elements
406        BigQuaternion aq, bq, cq, dq;
407        aq = cf.random(3);
408        bq = cf.random(3);
409        //System.out.println("aq = " + aq);
410        //System.out.println("bq = " + bq);
411
412        cq = aq.multiply(bq).conjugate();
413        dq = bq.conjugate().multiply(aq.conjugate());
414        //System.out.println("cq = " + cq);
415        //System.out.println("dq = " + dq);
416        assertEquals("con(a*b) == con(b)*con(a): ", cq, dq);
417
418        GenSolvablePolynomial<BigQuaternion> a, b, c, d;
419        a = pf.random(kl, ll, el, q);
420        //System.out.println("a = " + a);
421
422        // coefficients
423        GenSolvablePolynomial<BigQuaternion> ar, br, cr;
424        ar = (GenSolvablePolynomial<BigQuaternion>) a.reverse(pfr);
425        //System.out.println("StarRingElem case: " + a.ring.coFac.getONE().getClass());
426
427        GenSolvablePolynomial<BigQuaternion> arr = (GenSolvablePolynomial<BigQuaternion>) ar.reverse(pfrr);
428        assertEquals("a == arr", a, arr);
429        //System.out.println("ar = " + ar);
430        //System.out.println("arr = " + arr);
431
432        b = pf.random(kl, ll, el, q);
433        //System.out.println("b = " + b);
434        br = (GenSolvablePolynomial<BigQuaternion>) b.reverse(pfr);
435        //System.out.println("br = " + br);
436
437        c = b.multiply(a);
438        cr = ar.multiply(br);
439        //System.out.println("cr = " + cr);
440
441        d = (GenSolvablePolynomial<BigQuaternion>) cr.reverse(pfrr);
442        //System.out.println("d = " + d);
443        assertEquals("rev(a*b) == rev(b)*rev(a): ", c, d);
444    }
445
446
447    /**
448     * Test reversion with complex coefficients.
449     */
450    public void testReverseComplex() {
451        // complex numbers
452        BigComplex cf = new BigComplex();
453        // System.out.println("cf = " + cf);
454        String[] vars = new String[] { "x1", "x2", "x3", "x4" };
455
456        // polynomials over complex numbers
457        GenSolvablePolynomialRing<BigComplex> pf = new GenSolvablePolynomialRing<BigComplex>(cf, vars);
458        //System.out.println("pf = " + pf.toScript());
459
460        GenSolvablePolynomialRing<BigComplex> pfr = pf.reverse();
461        GenSolvablePolynomialRing<BigComplex> pfrr = pfr.reverse();
462        assertEquals("pf == pfrr", pf, pfrr);
463        //System.out.println("pfr = " + pfr);
464
465        int kl = 2;
466        int ll = 4;
467        int el = 3;
468        float q = 0.3f;
469
470        GenSolvablePolynomial<BigComplex> a, b, c, d;
471        GenSolvablePolynomial<BigComplex> ar, br, cr, dr;
472
473        a = pf.random(kl, ll, el, q);
474        //System.out.println("a = " + a);
475        ar = (GenSolvablePolynomial<BigComplex>) a.reverse(pfr);
476        GenSolvablePolynomial<BigComplex> arr = (GenSolvablePolynomial<BigComplex>) ar.reverse(pfrr);
477        assertEquals("a == arr", a, arr);
478        //System.out.println("ar = " + ar);
479        //System.out.println("arr = " + arr);
480
481        b = pf.random(kl, ll, el, q);
482        //System.out.println("b = " + b);
483        br = (GenSolvablePolynomial<BigComplex>) b.reverse(pfr);
484        //System.out.println("br = " + br);
485
486        c = b.multiply(a);
487        //System.out.println("c  = " + c);
488        cr = ar.multiply(br);
489        //System.out.println("cr = " + cr);
490
491        d = (GenSolvablePolynomial<BigComplex>) cr.reverse(pfrr);
492        //System.out.println("d = " + d);
493        //System.out.println("c-d = " + c.subtract(d));
494
495        dr = (GenSolvablePolynomial<BigComplex>) c.reverse(pfr);
496        //System.out.println("dr = " + dr);
497        //System.out.println("cr-dr = " + cr.subtract(dr));
498
499        assertEquals("b*a == rev(a)*rev(b): ", c, d);
500        assertEquals("rev(a)*rev(b) = b * a: ", cr, dr);
501    }
502
503
504    /**
505     * Test reversion with complex coefficients as Weyl algebra.
506     */
507    public void testReverseComplexWeyl() {
508        // complex numbers
509        BigComplex cf = new BigComplex();
510        // System.out.println("cf = " + cf);
511        String[] vars = new String[] { "x1", "x2", "x3", "x4" };
512
513        // polynomials over complex numbers
514        GenSolvablePolynomialRing<BigComplex> pf = new GenSolvablePolynomialRing<BigComplex>(cf, vars);
515        RelationGenerator<BigComplex> wl = new WeylRelations<BigComplex>();
516        wl.generate(pf);
517        //System.out.println("pf = " + pf.toScript());
518
519        GenSolvablePolynomialRing<BigComplex> pfr = pf.reverse();
520        //System.out.println("pfr = " + pfr.toScript());
521        GenSolvablePolynomialRing<BigComplex> pfrr = pfr.reverse();
522        assertEquals("pf == pfrr", pf, pfrr);
523
524        int kl = 2;
525        int ll = 4;
526        int el = 3;
527        float q = 0.3f;
528
529        GenSolvablePolynomial<BigComplex> a, b, c, d;
530        GenSolvablePolynomial<BigComplex> ar, br, cr, dr;
531
532        a = pf.random(kl, ll, el, q);
533        //System.out.println("a = " + a);
534        ar = (GenSolvablePolynomial<BigComplex>) a.reverse(pfr);
535        GenSolvablePolynomial<BigComplex> arr = (GenSolvablePolynomial<BigComplex>) ar.reverse(pfrr);
536        assertEquals("a == arr", a, arr);
537        //System.out.println("ar = " + ar);
538        //System.out.println("arr = " + arr);
539
540        b = pf.random(kl, ll, el, q);
541        //System.out.println("b = " + b);
542        br = (GenSolvablePolynomial<BigComplex>) b.reverse(pfr);
543        //System.out.println("br = " + br);
544
545        c = b.multiply(a);
546        //System.out.println("c  = " + c);
547        cr = ar.multiply(br);
548        //System.out.println("cr = " + cr);
549
550        d = (GenSolvablePolynomial<BigComplex>) cr.reverse(pfrr);
551        //System.out.println("d = " + d);
552        //System.out.println("c-d = " + c.subtract(d));
553
554        dr = (GenSolvablePolynomial<BigComplex>) c.reverse(pfr);
555        //System.out.println("dr = " + dr);
556        //System.out.println("cr-dr = " + cr.subtract(dr));
557
558        assertEquals("b*a == rev(a)*rev(b): ", c, d);
559        assertEquals("rev(a)*rev(b) = b * a: ", cr, dr);
560    }
561
562
563    /**
564     * Test reversion with quaternion coefficients and Weyl relations.
565     */
566    public void testReverseQuatWeyl() {
567        // quaternion numbers
568        BigQuaternionRing cf = new BigQuaternionRing();
569        // System.out.println("cf = " + cf);
570        String[] vars = new String[] { "x1", "x2", "x3", "x4" };
571
572        // polynomials over quaternion numbers
573        GenSolvablePolynomialRing<BigQuaternion> pf = new GenSolvablePolynomialRing<BigQuaternion>(cf, vars);
574        RelationGenerator<BigQuaternion> wl = new WeylRelations<BigQuaternion>();
575        wl.generate(pf);
576        //System.out.println("pf = " + pf.toScript());
577        GenSolvablePolynomialRing<BigQuaternion> pfr;
578        try {
579            pfr = pf.reverse();
580            assertFalse("pf coefficents commuative: " + pf, pf.coFac.isCommutative());
581        } catch (IllegalArgumentException e) {
582            assertTrue("pf coefficents commuative: " + pf, pf.coFac.isCommutative());
583            pfr = null;
584        }
585        //System.out.println("pf = " + pf.toScript());
586        //System.out.println("pfr = " + pfr.toScript());
587        GenSolvablePolynomialRing<BigQuaternion> pfrr = pfr.reverse();
588        assertEquals("pf == pfrr", pf, pfrr);
589
590        // elements
591        BigQuaternion aq, bq, cq, dq;
592        aq = cf.random(3);
593        bq = cf.random(3);
594        //System.out.println("aq = " + aq);
595        //System.out.println("bq = " + bq);
596
597        cq = aq.multiply(bq).conjugate();
598        dq = bq.conjugate().multiply(aq.conjugate());
599        //System.out.println("cq = " + cq);
600        //System.out.println("dq = " + dq);
601        assertEquals("con(a*b) == con(b)*con(a): ", cq, dq);
602
603        GenSolvablePolynomial<BigQuaternion> a, b, c, d;
604        a = pf.random(kl, ll, el, q);
605        //System.out.println("a = " + a);
606
607        // coefficients
608        GenSolvablePolynomial<BigQuaternion> ar, br, cr;
609        ar = (GenSolvablePolynomial<BigQuaternion>) a.reverse(pfr);
610
611        GenSolvablePolynomial<BigQuaternion> arr = (GenSolvablePolynomial<BigQuaternion>) ar.reverse(pfrr);
612        assertEquals("a == arr", a, arr);
613        //System.out.println("ar = " + ar);
614        //System.out.println("arr = " + arr);
615
616        b = pf.random(kl, ll, el, q);
617        //System.out.println("b = " + b);
618        br = (GenSolvablePolynomial<BigQuaternion>) b.reverse(pfr);
619        //System.out.println("br = " + br);
620
621        c = b.multiply(a);
622        cr = ar.multiply(br);
623        //System.out.println("cr = " + cr);
624
625        d = (GenSolvablePolynomial<BigQuaternion>) cr.reverse(pfrr);
626        //System.out.println("d = " + d);
627        assertEquals("rev(a*b) == rev(b)*rev(a): ", c, d);
628    }
629
630}