Source code

001/*
002 * $Id: QuotSolvablePolynomialTest.java 5691 2017-01-08 18:43:48Z kredel $
003 */
004
005package edu.jas.fd;
006
007
008import java.util.List;
009
010import org.apache.log4j.BasicConfigurator;
011
012import edu.jas.arith.BigRational;
013import edu.jas.poly.ExpVector;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenSolvablePolynomial;
016import edu.jas.poly.GenSolvablePolynomialRing;
017import edu.jas.poly.RecSolvablePolynomial;
018import edu.jas.poly.RelationGenerator;
019import edu.jas.poly.TermOrder;
020import edu.jas.poly.WeylRelations;
021import edu.jas.kern.ComputerThreads;
022
023import junit.framework.Test;
024import junit.framework.TestCase;
025import junit.framework.TestSuite;
026
027
028/**
029 * BigRational coefficients QuotSolvablePolynomial tests with JUnit.
030 * @author Heinz Kredel
031 */
032
033public class QuotSolvablePolynomialTest extends TestCase {
034
035
036    /**
037     * main.
038     */
039    public static void main(String[] args) {
040        BasicConfigurator.configure();
041        junit.textui.TestRunner.run(suite());
042        ComputerThreads.terminate();
043    }
044
045
046    /**
047     * Constructs a <CODE>QuotSolvablePolynomialTest</CODE> object.
048     * @param name String.
049     */
050    public QuotSolvablePolynomialTest(String name) {
051        super(name);
052    }
053
054
055    /**
056     */
057    public static Test suite() {
058        TestSuite suite = new TestSuite(QuotSolvablePolynomialTest.class);
059        return suite;
060    }
061
062
063    QuotSolvablePolynomial<BigRational> a, b, c, d, e, f, x1, x2;
064
065
066    int rl = 4;
067
068
069    int kl = 1;
070
071
072    int ll = 4;
073
074
075    int el = 3;
076
077
078    float q = 0.2f;
079
080
081    String[] cvars = new String[] { "a", "b" };
082
083
084    String[] vars = new String[] { "w", "x", "y", "z" };
085
086
087    QuotSolvablePolynomialRing<BigRational> ring;
088
089
090    BigRational cfac;
091
092
093    GenSolvablePolynomialRing<SolvableQuotient<BigRational>> sring;
094
095
096    GenSolvablePolynomialRing<BigRational> cring;
097
098
099    SolvableQuotientRing<BigRational> qcring;
100
101
102    TermOrder tord = new TermOrder(TermOrder.INVLEX);
103
104
105    @Override
106    protected void setUp() {
107        cfac = new BigRational(1);
108        cring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
109        qcring = new SolvableQuotientRing<BigRational>(cring);
110        ring = new QuotSolvablePolynomialRing<BigRational>(qcring, tord, vars);
111        RelationGenerator<SolvableQuotient<BigRational>> wl = new WeylRelations<SolvableQuotient<BigRational>>();
112        ring.addRelations(wl); //wl.generate(ring);
113        a = b = c = d = e = null;
114    }
115
116
117    @Override
118    protected void tearDown() {
119        ring = null;
120        a = b = c = d = e = null;
121    }
122
123
124    /**
125     * Test constructor, generators and properties.
126     */
127    public void testConstructor() {
128        assertFalse("not commutative", ring.isCommutative());
129        assertTrue("associative", ring.isAssociative());
130
131        a = new QuotSolvablePolynomial<BigRational>(ring);
132        assertTrue("length( a ) = 0", a.length() == 0);
133        assertTrue("isZERO( a )", a.isZERO());
134        assertTrue("isONE( a )", !a.isONE());
135
136        c = ring.getONE();
137        assertTrue("length( c ) = 1", c.length() == 1);
138        assertTrue("isZERO( c )", !c.isZERO());
139        assertTrue("isONE( c )", c.isONE());
140
141        d = ring.getZERO();
142        assertTrue("length( d ) = 0", d.length() == 0);
143        assertTrue("isZERO( d )", d.isZERO());
144        assertTrue("isONE( d )", !d.isONE());
145        //System.out.println("d = " + d);
146
147        //System.out.println("");
148        for (GenPolynomial<SolvableQuotient<BigRational>> g : ring.generators()) {
149            //System.out.print("g = " + g + ", ");
150            assertFalse("not isZERO( g )", g.isZERO());
151        }
152        //System.out.println("");
153        assertTrue("isAssociative: ", ring.isAssociative());
154    }
155
156
157    /**
158     * Test random polynomial.
159     */
160    public void testRandom() {
161        for (int i = 0; i < 3; i++) {
162            // a = ring.random(ll+2*i);
163            a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q);
164            //System.out.println("a = " + a);
165            assertTrue("length( a" + i + " ) <> 0", a.length() >= 0);
166            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
167            assertTrue(" not isONE( a" + i + " )", !a.isONE());
168        }
169    }
170
171
172    /**
173     * Test addition.
174     */
175    public void testAddition() {
176        a = ring.random(kl, ll, el, q);
177        c = (QuotSolvablePolynomial<BigRational>) a.subtract(a);
178        assertTrue("a-a = 0", c.isZERO());
179
180        b = (QuotSolvablePolynomial<BigRational>) a.sum(a);
181        c = (QuotSolvablePolynomial<BigRational>) b.subtract(a);
182        assertEquals("a+a-a = a", c, a);
183
184        b = ring.random(kl, ll, el, q);
185        c = (QuotSolvablePolynomial<BigRational>) b.sum(a);
186        d = (QuotSolvablePolynomial<BigRational>) a.sum(b);
187        assertEquals("a+b = b+a", c, d);
188
189        c = ring.random(kl, ll, el, q);
190        d = (QuotSolvablePolynomial<BigRational>) a.sum(b.sum(c));
191        e = (QuotSolvablePolynomial<BigRational>) a.sum(b).sum(c);
192        assertEquals("a+(b+c) = (a+b)+c", d, e);
193        //System.out.println("a = " + a);
194        //System.out.println("b = " + b);
195        //System.out.println("c = " + c);
196        //System.out.println("d = " + d);
197        //System.out.println("e = " + e);
198
199        ExpVector u = ExpVector.EVRAND(rl, el, q);
200        SolvableQuotient<BigRational> x = qcring.random(kl);
201        //System.out.println("x = " + x);
202        //System.out.println("u = " + u);
203
204        b = ring.getONE().multiply(x, u);
205        c = (QuotSolvablePolynomial<BigRational>) a.sum(b);
206        d = (QuotSolvablePolynomial<BigRational>) a.sum(x, u);
207        //System.out.println("a = " + a);
208        //System.out.println("b = " + b);
209        //System.out.println("c = " + c);
210        //System.out.println("d = " + d);
211        assertEquals("a+p(x,u) = a+(x,u)", c, d);
212
213        c = (QuotSolvablePolynomial<BigRational>) a.subtract(b);
214        d = (QuotSolvablePolynomial<BigRational>) a.subtract(x, u);
215        assertEquals("a-p(x,u) = a-(x,u)", c, d);
216
217        a = ring.getZERO();
218        b = ring.getONE().multiply(x, u);
219        c = (QuotSolvablePolynomial<BigRational>) b.sum(a);
220        d = (QuotSolvablePolynomial<BigRational>) a.sum(x, u);
221        assertEquals("a+p(x,u) = a+(x,u)", c, d);
222
223        c = (QuotSolvablePolynomial<BigRational>) a.subtract(b);
224        d = (QuotSolvablePolynomial<BigRational>) a.subtract(x, u);
225        assertEquals("a-p(x,u) = a-(x,u)", c, d);
226    }
227
228
229    /**
230     * Test multiplication.
231     */
232    public void testMultiplication() {
233        //System.out.println("ring = " + ring);
234        a = ring.random(kl, ll - 1, el - 1, q);
235        //a = ring.parse(" b y z + a w z ");  
236        b = ring.random(kl, ll - 1, el - 1, q);
237        //b = ring.parse(" w x - b x "); 
238
239        c = b.multiply(a);
240        d = a.multiply(b);
241        //System.out.println("a = " + a);
242        //System.out.println("b = " + b);
243        //System.out.println("c = " + c);
244        //System.out.println("d = " + d);
245        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
246
247        c = ring.random(kl, ll - 1, el - 1, q);
248        d = a.multiply(b.multiply(c));
249        e = a.multiply(b).multiply(c);
250        assertEquals("a(bc) = (ab)c", d, e);
251        //System.out.println("a = " + a);
252        //System.out.println("b = " + b);
253        //System.out.println("c = " + c);
254        //System.out.println("d = " + d);
255        //System.out.println("e = " + e);
256
257        SolvableQuotient<BigRational> xp = a.leadingBaseCoefficient().inverse();
258        d = a.multiply(xp);
259        assertTrue("monic(a) = a*(1/ldcf(ldcf(a)))", d.leadingBaseCoefficient().isONE());
260
261        d = (QuotSolvablePolynomial<BigRational>) a.monic();
262        assertTrue("a.monic(): ", d.leadingBaseCoefficient().isONE());
263    }
264
265
266    /**
267     * Test commutative ring.
268     */
269    public void testCommutative() {
270        //System.out.println("table = " + table.toString(vars));
271        //System.out.println("table = " + table.toScript());
272        //System.out.println("ring = " + ring);
273        //System.out.println("ring.table = " + ring.table.toScript());
274        //assertEquals("table == ring.table: ", table, ring.table); // ?
275        assertTrue("# relations == 2", ring.table.size() == 2);
276
277        ring = new QuotSolvablePolynomialRing<BigRational>(qcring, ring);
278        //System.out.println("ring = " + ring);
279
280        assertTrue("isCommutative()", ring.isCommutative());
281        assertTrue("isAssociative()", ring.isAssociative());
282
283        a = ring.random(kl, ll, el, q);
284        //a = ring.parse(" b x y z + a w z ");
285        //System.out.println("a = " + a);
286        b = ring.random(kl, ll, el, q);
287        //b = ring.parse(" w y z - b x ");
288        //System.out.println("b = " + b);
289
290        // commutative
291        c = b.multiply(a);
292        //System.out.println("c = " + c);
293        d = a.multiply(b);
294        //d = ring.getONE(); 
295        //System.out.println("d = " + d);
296        assertEquals("b*a == a*b: ", c, d);
297    }
298
299
300    /**
301     * Test distributive law.
302     */
303    public void testDistributive() {
304        a = ring.random(kl, ll, el, q);
305        b = ring.random(kl, ll, el, q);
306        c = ring.random(kl, ll, el, q);
307
308        d = a.multiply((QuotSolvablePolynomial<BigRational>) b.sum(c));
309        e = (QuotSolvablePolynomial<BigRational>) a.multiply(b).sum(a.multiply(c));
310        assertEquals("a*(b+c) = a*b+a*c", d, e);
311    }
312
313
314    /**
315     * Test solvable coefficient ring.
316     */
317    public void testSolvableCoeffs() {
318        GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac, tord,
319                        cvars);
320        //RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(csring); 
321        //no: wlc.generate(csring);
322        //assertTrue("# relations == 1", csring.table.size() == 1);
323        assertTrue("isCommutative()", csring.isCommutative());
324        assertTrue("isAssociative()", csring.isAssociative());
325
326        SolvableQuotientRing<BigRational> qcsring = new SolvableQuotientRing<BigRational>(csring);
327        //assertFalse("isCommutative()", qcsring.isCommutative());
328        assertTrue("isAssociative()", qcsring.isAssociative());
329
330        ring = new QuotSolvablePolynomialRing<BigRational>(qcsring, ring);
331        RelationGenerator<SolvableQuotient<BigRational>> wl = new WeylRelations<SolvableQuotient<BigRational>>();
332        wl.generate(ring);
333        assertTrue("# relations == 2", ring.table.size() == 2);
334        assertFalse("isCommutative()", ring.isCommutative());
335        assertTrue("isAssociative()", ring.isAssociative());
336        //System.out.println("ring = " + ring);
337
338        RecSolvablePolynomial<BigRational> r1 = ring.polCoeff.parse("x");
339        GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
340        RecSolvablePolynomial<BigRational> rp = ring.polCoeff.parse("b x + a"); // + a
341        //System.out.println("r1 = " + r1);
342        //System.out.println("r2 = " + r2);
343        //System.out.println("rp = " + rp);
344        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
345        //System.out.println("ring.polCoeff = " + ring.polCoeff);
346
347        assertFalse("isCommutative()", ring.isCommutative());
348        assertTrue("isAssociative()", ring.isAssociative());
349
350        List<GenPolynomial<SolvableQuotient<BigRational>>> gens = ring.generators();
351        //gens = new ArrayList<GenPolynomial<SolvableQuotient<BigRational>>>();
352
353        for (GenPolynomial<SolvableQuotient<BigRational>> x : gens) {
354            GenSolvablePolynomial<SolvableQuotient<BigRational>> xx = (GenSolvablePolynomial<SolvableQuotient<BigRational>>) x;
355            a = new QuotSolvablePolynomial<BigRational>(ring, xx);
356            //System.out.println("a = " + a);
357            for (GenPolynomial<SolvableQuotient<BigRational>> y : gens) {
358                GenSolvablePolynomial<SolvableQuotient<BigRational>> yy = (GenSolvablePolynomial<SolvableQuotient<BigRational>>) y;
359                b = new QuotSolvablePolynomial<BigRational>(ring, yy);
360                //System.out.println("b = " + b);
361                c = a.multiply(b);
362                //System.out.println("gens: " + a + " * " + b + " = " + c);
363                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
364                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
365            }
366        }
367
368        //a = ring.random(kl, ll, el, q);
369        //a = ring.getONE();
370        a = ring.parse("x^2 + a b");
371        //System.out.println("a = " + a.toScript());
372        //b = ring.random(kl, ll, el, q);
373        //b = ring.getONE();
374        b = ring.parse("a b^2 + a"); // + a 
375        b = (QuotSolvablePolynomial<BigRational>) b.inverse();
376        //System.out.println("b = " + b.toScript());
377
378        // non-commutative
379        c = b.multiply(a);
380        d = a.multiply(b);
381        //System.out.println("a = " + a.toScript());
382        //System.out.println("b = " + b.toScript());
383        //System.out.println("c = " + c.toScript());
384        //System.out.println("d = " + d.toScript());
385        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
386
387        e = (QuotSolvablePolynomial<BigRational>) b.inverse();
388        //System.out.println("e = " + e.toScript());
389        assertTrue("b*b^-1 == 1", e.multiply(b).isONE());
390
391        c = e.multiply(c);
392        d = d.multiply(e);
393        //System.out.println("a = " + a.toScript());
394        //System.out.println("b = " + b.toScript());
395        //System.out.println("c = " + c.toScript());
396        //System.out.println("d = " + d.toScript());
397        assertTrue("a == b * 1/b * a", a.equals(c));
398        assertTrue("a == a * 1/b * b", a.equals(d));
399    }
400
401
402    /*
403     * Test extension and contraction for Weyl relations. public void
404     * testExtendContractWeyl() { GenSolvablePolynomialRing<BigRational> csring
405     * = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
406     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
407     * wlc.generate(csring); assertFalse("isCommutative()", csring.isCommutative());
408     * assertTrue("isAssociative()", csring.isAssociative());
409     * 
410     * QuotSolvablePolynomial<BigRational> r1 = ring.parse("x");
411     * GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
412     * QuotSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
413     * ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
414     * 
415     * int k = rl; QuotSolvablePolynomialRing<BigRational> pfe = ring.extend(k);
416     * //System.out.println("pfe = " + pfe);
417     * QuotSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
418     * //System.out.println("pfec = " + pfec); assertEquals("ring == pfec",
419     * ring, pfec);
420     * 
421     * QuotSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q);
422     * //System.out.println("a = " + a);
423     * 
424     * QuotSolvablePolynomial<BigRational> ae =
425     * (QuotSolvablePolynomial<BigRational>) a.extend(pfe, 0, 0);
426     * //System.out.println("ae = " + ae);
427     * 
428     * Map<ExpVector, GenPolynomial<GenPolynomial<BigRational>>> m =
429     * ae.contract(pfec); List<GenPolynomial<GenPolynomial<BigRational>>> ml =
430     * new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>( m.values());
431     * GenPolynomial<GenPolynomial<BigRational>> aec = ml.get(0);
432     * //System.out.println("ae  = " + ae); //System.out.println("aec = " +
433     * aec); assertEquals("a == aec", a, aec); }
434     */
435
436
437    /*
438     * Test reversion for Weyl relations. public void testReverseWeyl() {
439     * GenSolvablePolynomialRing<BigRational> csring = new
440     * GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
441     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
442     * wlc.generate(csring); assertFalse("isCommutative()", csring.isCommutative());
443     * assertTrue("isAssociative()", csring.isAssociative());
444     * 
445     * QuotSolvablePolynomial<BigRational> r1 = ring.parse("x");
446     * GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
447     * QuotSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
448     * ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
449     * 
450     * QuotSolvablePolynomialRing<BigRational> pfr = ring.reverse();
451     * QuotSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
452     * assertEquals("pf == pfrr", ring, pfrr); //System.out.println("ring = " +
453     * ring); //System.out.println("pfr = " + pfr);
454     * 
455     * QuotSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q);
456     * //System.out.println("a = " + a);
457     * 
458     * QuotSolvablePolynomial<BigRational> ar =
459     * (QuotSolvablePolynomial<BigRational>) a.reverse(pfr);
460     * QuotSolvablePolynomial<BigRational> arr =
461     * (QuotSolvablePolynomial<BigRational>) ar.reverse(pfrr);
462     * assertEquals("a == arr", a, arr); //System.out.println("ar = " + ar);
463     * //System.out.println("arr = " + arr); }
464     */
465
466
467    /*
468     * Test recursive for Weyl relations. public void testRecursiveWeyl() {
469     * String[] svars = new String[] { "w", "x", "y", "z" };
470     * GenSolvablePolynomialRing<BigRational> sring = new
471     * GenSolvablePolynomialRing<BigRational>(cfac, tord, svars);
472     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
473     * wlc.generate(sring); assertFalse("isCommutative()", sring.isCommutative());
474     * assertTrue("isAssociative()", sring.isAssociative());
475     * //System.out.println("sring = " + sring.toScript());
476     * 
477     * GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring =
478     * sring.recursive(2); // 1,2,3 //System.out.println("rsring = " + rsring);
479     * //.toScript()); System.out.println("rsring = " + rsring.toScript());
480     * 
481     * GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
482     * QuotSolvablePolynomial<BigRational> ar, br, cr, dr; ad = sring.random(kl,
483     * ll, el, q); bd = sring.random(kl, ll, el, q); //ad =
484     * sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225"); //bd =
485     * sring.parse("-10/13 x "); //+ 413/150"); //ad =
486     * (GenSolvablePolynomial<BigRational>) ad.monic(); //bd =
487     * (GenSolvablePolynomial<BigRational>) bd.monic();
488     * 
489     * //System.out.println("ad = " + ad); //System.out.println("bd = " + bd);
490     * 
491     * cd = ad.multiply(bd); //System.out.println("cd = " + cd);
492     * 
493     * ar = (QuotSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
494     * recursive(rsring, ad); br = (QuotSolvablePolynomial<BigRational>)
495     * PolyUtil.<BigRational> recursive(rsring, bd);
496     * //System.out.println("ar = " + ar); //System.out.println("br = " + br);
497     * 
498     * cr = ar.multiply(br); //System.out.println("cr = " + cr);
499     * //System.out.println("cr.ring = " + cr.ring.toScript());
500     * 
501     * dr = (QuotSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
502     * recursive(rsring, cd); //System.out.println("dr = " + dr);
503     * 
504     * assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
505     * assertEquals("dr == cr", dr, cr);
506     * 
507     * dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
508     * distribute(sring, cr); //System.out.println("dd = " + dd);
509     * assertEquals("dd == cd", dd, cd); }
510     */
511
512
513    /*
514     * Test recursive for iterated Weyl relations. public void
515     * testRecursiveIteratedWeyl() { String[] svars = new String[] { "w", "x",
516     * "y", "z" }; GenSolvablePolynomialRing<BigRational> sring = new
517     * GenSolvablePolynomialRing<BigRational>(cfac, tord, svars);
518     * RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>();
519     * wlc.generate(sring); assertFalse("isCommutative()",
520     * sring.isCommutative()); assertTrue("isAssociative()",
521     * sring.isAssociative()); //System.out.println("sring = " +
522     * sring.toScript());
523     * 
524     * GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring =
525     * sring.recursive(2); // 1,2,3 //System.out.println("rsring = " + rsring);
526     * //.toScript()); System.out.println("rsring = " + rsring.toScript());
527     * 
528     * GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
529     * QuotSolvablePolynomial<BigRational> ar, br, cr, dr; ad = sring.random(kl,
530     * ll, el, q); bd = sring.random(kl, ll, el, q); //ad =
531     * (GenSolvablePolynomial<BigRational>) ad.monic(); //bd =
532     * (GenSolvablePolynomial<BigRational>) bd.monic();
533     * 
534     * //System.out.println("ad = " + ad); //System.out.println("bd = " + bd);
535     * 
536     * cd = ad.multiply(bd); //System.out.println("cd = " + cd);
537     * 
538     * ar = (QuotSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
539     * recursive(rsring, ad); br = (QuotSolvablePolynomial<BigRational>)
540     * PolyUtil.<BigRational> recursive(rsring, bd);
541     * //System.out.println("ar = " + ar); //System.out.println("br = " + br);
542     * 
543     * cr = ar.multiply(br); //System.out.println("cr = " + cr);
544     * 
545     * dr = (QuotSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
546     * recursive(rsring, cd); //System.out.println("dr = " + dr);
547     * 
548     * assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
549     * assertEquals("dr == cr", dr, cr);
550     * 
551     * dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
552     * distribute(sring, cr); //System.out.println("dd = " + dd);
553     * assertEquals("dd == cd", dd, cd); }
554     */
555
556}