Source code

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