Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016
017import edu.jas.arith.BigRational;
018import edu.jas.poly.GenSolvablePolynomial;
019import edu.jas.poly.GenSolvablePolynomialRing;
020import edu.jas.poly.RelationGenerator;
021import edu.jas.poly.WeylRelations;
022import edu.jas.poly.TermOrder;
023import edu.jas.structure.NotInvertibleException;
024
025
026/**
027 * SolvableResidue tests with JUnit. 
028 * @author Heinz Kredel
029 */
030
031public class SolvableResidueTest extends TestCase {
032
033    /**
034     * main.
035     */
036    public static void main (String[] args) {
037        
038        junit.textui.TestRunner.run( suite() );
039    }
040
041    /**
042     * Constructs a <CODE>SolvableResidueTest</CODE> object.
043     * @param name String.
044     */
045    public SolvableResidueTest(String name) {
046        super(name);
047    }
048
049    /**
050     * suite.
051     */ 
052    public static Test suite() {
053        TestSuite suite= new TestSuite(SolvableResidueTest.class);
054        return suite;
055    }
056
057    SolvableIdeal<BigRational> id;
058    SolvableResidueRing<BigRational> fac;
059    GenSolvablePolynomialRing<BigRational> mfac;
060    List<GenSolvablePolynomial<BigRational>> F;
061
062    SolvableResidue< BigRational > a, b, c, d, e;
063
064    int rl = 4; 
065    int kl = 2;
066    int ll = 3;
067    int el = 2;
068    float q = 0.2f;
069    int il = ( rl == 1 ? 1 : 2 ); 
070
071    protected void setUp() {
072        a = b = c = d = e = null;
073        TermOrder to = new TermOrder( TermOrder.INVLEX );
074        String[] vars = new String[] { "w", "x", "y", "z" };
075        mfac = new GenSolvablePolynomialRing<BigRational>( new BigRational(1), rl, to, vars );
076        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
077        wl.generate(mfac);
078        if (!mfac.isAssociative() ) {
079           System.out.println("ring not associative: " + mfac);
080        }
081        do {
082            F = new ArrayList<GenSolvablePolynomial<BigRational>>( il );
083            for ( int i = 0; i < il; i++ ) {
084                GenSolvablePolynomial<BigRational> mo = mfac.random(kl,ll,el,q);
085                while ( mo.isConstant() ) {
086                    mo = mfac.random(kl,ll,el,q);
087                }
088                F.add( mo );
089            }
090            id = new SolvableIdeal<BigRational>(mfac,F);
091            id.doGB();
092        } while (id.isONE());
093        //System.out.println("id = " + id);
094        assert !id.isONE() : "id = " + id;
095        fac = new SolvableResidueRing<BigRational>( id );
096        //System.out.println("fac = " + fac);
097        F = null;
098    }
099
100    protected void tearDown() {
101        a = b = c = d = e = null;
102        fac = null;
103        id = null;
104        mfac = null;
105    }
106
107
108    /**
109     * Test constructor and toString.
110     */
111    public void testConstruction() {
112        c = fac.getONE();
113        //System.out.println("c = " + c);
114        //System.out.println("c.val = " + c.val);
115        assertTrue("length( c ) = 1 ", c.val.length() == 1 || id.isONE());
116        assertTrue("isZERO( c )", !c.isZERO() || id.isONE());
117        assertTrue("isONE( c )", c.isONE() || id.isONE());
118
119        d = fac.getZERO();
120        //System.out.println("d = " + d);
121        //System.out.println("d.val = " + d.val);
122        assertTrue("length( d ) = 0", d.val.length() == 0);
123        assertTrue("isZERO( d )", d.isZERO() );
124        assertTrue("isONE( d )", !d.isONE() );
125
126        for (SolvableResidue<BigRational> g : fac.generators() ) {
127            //System.out.println("g = " + g);
128            assertFalse("not isZERO( g )", g.isZERO() );
129        }
130    }
131
132
133    /**
134     * Test random polynomial.
135     */
136    public void testRandom() {
137        for (int i = 1; i < 7; i++) {
138            //a = fac.random(ll+i);
139            a = fac.random(kl*(i+1), ll+2*i, el+i, q );
140            //System.out.println("a = " + a);
141            if ( a.isZERO() || a.isONE() ) {
142                continue;
143            }
144            assertTrue("length( a"+i+" ) <> 0", a.val.length() >= 0);
145            assertTrue(" not isZERO( a"+i+" )", !a.isZERO() );
146            assertTrue(" not isONE( a"+i+" )", !a.isONE() );
147        }
148    }
149
150
151    /**
152     * Test addition.
153     */
154    public void testAddition() {
155        a = fac.random(kl,ll,el,q);
156        b = fac.random(kl,ll,el,q);
157
158        c = a.sum(b);
159        d = c.subtract(b);
160        assertEquals("a+b-b = a",a,d);
161
162        c = a.sum(b);
163        d = b.sum(a);
164        assertEquals("a+b = b+a",c,d);
165
166        c = fac.random(kl,ll,el,q);
167        d = c.sum( a.sum(b) );
168        e = c.sum( a ).sum(b);
169        assertEquals("c+(a+b) = (c+a)+b",d,e);
170
171        c = a.sum( fac.getZERO() );
172        d = a.subtract( fac.getZERO() );
173        assertEquals("a+0 = a-0",c,d);
174
175        c = fac.getZERO().sum( a );
176        d = fac.getZERO().subtract( a.negate() );
177        assertEquals("0+a = 0+(-a)",c,d);
178    }
179
180
181    /**
182     * Test object multiplication.
183     */
184    public void testMultiplication() {
185        List<SolvableResidue<BigRational>> g = fac.generators();
186        //System.out.println("g = " + g);
187        //a = fac.random(kl,ll,el,q);
188        a = g.get(1);
189        if ( a.isZERO() ) {
190            a = fac.getONE(); //return;
191        }
192        assertTrue("not isZERO( a )", !a.isZERO() );
193
194        b = fac.random(kl,ll,el,q);
195        //b = g.get(g.size()-1);
196        if ( b.isZERO() ) {
197            b = fac.getONE(); //return;
198        }
199        assertTrue("not isZERO( b )", !b.isZERO() );
200
201        c = a.multiply( fac.getONE() );
202        d = fac.getONE().multiply( a );
203        assertEquals("a*1 = 1*a",c,d);
204        assertEquals("a*1 = 1*a",c,a);
205
206        c = b.multiply(a);
207        d = a.multiply(b);
208        assertTrue("not isZERO( c )", !c.isZERO() );
209        assertTrue("not isZERO( d )", !d.isZERO() );
210
211        //System.out.println("a = " + a);
212        //System.out.println("b = " + b);
213        //System.out.println("c = " + c);
214        //System.out.println("d = " + d);
215        //e = d.subtract(c);
216        //non-com: assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO() );
217        //non-com: assertEquals("a*b = b*a",c,d);
218
219        c = fac.random(kl,ll+1,el,q);
220        //System.out.println("c = " + c);
221        d = a.multiply( b.multiply(c) );
222        e = a.multiply(b).multiply(c);
223        //System.out.println("d = " + d);
224        //System.out.println("e = " + e);
225        //System.out.println("d-e = " + d.subtract(e) );
226        assertEquals("a(bc) = (ab)c",d,e);
227        //assertTrue("a(bc) = (ab)c", d.equals(e) );
228
229        if ( !a.isZERO() ) { // !a.isZERO() isUnit()
230            try {
231                 c = a.inverse();
232                 //System.out.println("a = " + a);
233                 //System.out.println("c = " + c);
234                 d = c.multiply(a);
235                 //System.out.println("d = " + d);
236                 assertTrue("a*1/a = 1: " + fac, d.isONE()); // || true 
237            } catch (NotInvertibleException e) {
238                 // can happen
239            }
240        }
241
242        // d = c.remainder(a);
243        // //System.out.println("c = " + c);
244        // System.out.println("d = " + d);
245        // if ( d.isZERO() ) {
246        //     d = c.divide(a);
247        //     System.out.println("c = " + c);
248        //     System.out.println("d = " + d);
249        //     e = a.multiply(d);
250        //     System.out.println("e = " + e);
251        //     assertEquals("((b*a)/a)*a = b*a",e,c);
252        // }
253    }
254
255}