001 /*
002 * $Id: FactorRationalTest.java 3733 2011-08-13 20:08:25Z kredel $
003 */
004
005 package edu.jas.ufd;
006
007 import java.util.SortedMap;
008
009 import org.apache.log4j.BasicConfigurator;
010
011 import junit.framework.Test;
012 import junit.framework.TestCase;
013 import junit.framework.TestSuite;
014
015 import edu.jas.arith.BigRational;
016 import edu.jas.kern.ComputerThreads;
017 import edu.jas.poly.GenPolynomial;
018 import edu.jas.poly.GenPolynomialRing;
019 import edu.jas.poly.TermOrder;
020
021
022 /**
023 * Factor rational tests with JUnit.
024 * @author Heinz Kredel.
025 */
026
027 public class FactorRationalTest extends TestCase {
028
029
030 /**
031 * main.
032 */
033 public static void main(String[] args) {
034 BasicConfigurator.configure();
035 junit.textui.TestRunner.run(suite());
036 }
037
038
039 /**
040 * Constructs a <CODE>FactorRationalTest</CODE> object.
041 * @param name String.
042 */
043 public FactorRationalTest(String name) {
044 super(name);
045 }
046
047
048 /**
049 */
050 public static Test suite() {
051 TestSuite suite = new TestSuite(FactorRationalTest.class);
052 return suite;
053 }
054
055
056 int rl = 3;
057
058
059 int kl = 5;
060
061
062 int ll = 5;
063
064
065 int el = 3;
066
067
068 float q = 0.3f;
069
070
071 @Override
072 protected void setUp() {
073 }
074
075
076 @Override
077 protected void tearDown() {
078 ComputerThreads.terminate();
079 }
080
081
082 /**
083 * Test dummy for Junit.
084 */
085 public void testDummy() {
086 }
087
088
089 /**
090 * Test rational univariate factorization.
091 */
092 public void testRationalFactorization() {
093 TermOrder to = new TermOrder(TermOrder.INVLEX);
094 BigRational cfac = new BigRational(1);
095 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to);
096 FactorRational fac = new FactorRational();
097
098 for (int i = 1; i < 3; i++) {
099 int facs = 0;
100 GenPolynomial<BigRational> a;
101 GenPolynomial<BigRational> c = pfac.random(kl - 2, ll * i, el + i, q);
102 // a = a.monic();
103 GenPolynomial<BigRational> b = pfac.random(kl - 2, ll, el, q);
104 //b = b.monic();
105 // if ( false && ! a.leadingBaseCoefficient().isONE() ) {
106 //continue;
107 //ExpVector e = a.leadingExpVector();
108 //a.doPutToMap(e,cfac.getONE());
109 //}
110 if (b.isZERO() || c.isZERO()) {
111 continue;
112 }
113 if (c.degree() > 0) {
114 facs++;
115 }
116 if (b.degree() > 0) {
117 facs++;
118 }
119 a = c.multiply(b);
120 //System.out.println("\na = " + a);
121 //System.out.println("b = " + b);
122 //System.out.println("c = " + c);
123
124 SortedMap<GenPolynomial<BigRational>, Long> sm = fac.baseFactors(a);
125 //System.out.println("\na = " + a);
126 //System.out.println("sm = " + sm);
127 if (sm.size() >= facs) {
128 assertTrue("#facs < " + facs, sm.size() >= facs);
129 } else {
130 long sf = 0;
131 for (Long e : sm.values()) {
132 sf += e;
133 }
134 assertTrue("#facs < " + facs + ", b = " + b + ", c = " + c + ", sm = " + sm, sf >= facs);
135 }
136 boolean t = fac.isFactorization(a, sm);
137 //System.out.println("t = " + t);
138 assertTrue("prod(factor(a)) = a", t);
139 }
140 }
141
142
143 /**
144 * Test rational multivariate factorization.
145 */
146 public void testRationalMultiFactorization() {
147 TermOrder to = new TermOrder(TermOrder.INVLEX);
148 BigRational cfac = new BigRational(1);
149 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 2, to);
150 FactorRational fac = new FactorRational();
151
152 for (int i = 1; i < 3; i++) {
153 int facs = 0;
154 GenPolynomial<BigRational> a;
155 GenPolynomial<BigRational> c = pfac.random(kl - 2, ll * i, el + i, q);
156 // a = a.monic();
157 GenPolynomial<BigRational> b = pfac.random(kl - 2, ll, el, q);
158 //b = b.monic();
159 // if ( false && ! a.leadingBaseCoefficient().isONE() ) {
160 //continue;
161 //ExpVector e = a.leadingExpVector();
162 //a.doPutToMap(e,cfac.getONE());
163 //}
164 if (b.isZERO() || c.isZERO()) {
165 continue;
166 }
167 if (c.degree() > 0) {
168 facs++;
169 }
170 if (b.degree() > 0) {
171 facs++;
172 }
173 a = c.multiply(b);
174 //System.out.println("\na = " + a);
175 //System.out.println("b = " + b);
176 //System.out.println("c = " + c);
177
178 SortedMap<GenPolynomial<BigRational>, Long> sm = fac.factors(a);
179 //System.out.println("\na = " + a);
180 //System.out.println("sm = " + sm);
181 if (sm.size() >= facs) {
182 assertTrue("#facs < " + facs, sm.size() >= facs);
183 } else {
184 long sf = 0;
185 for (Long e : sm.values()) {
186 sf += e;
187 }
188 assertTrue("#facs < " + facs + ", b = " + b + ", c = " + c + ", sm = " + sm, sf >= facs);
189 }
190 boolean t = fac.isFactorization(a, sm);
191 //System.out.println("t = " + t);
192 assertTrue("prod(factor(a)) = a", t);
193 }
194 }
195
196
197 /**
198 * Test rational absolute factorization.
199 */
200 public void testBaseRationalAbsoluteFactorization() {
201 TermOrder to = new TermOrder(TermOrder.INVLEX);
202 BigRational cfac = new BigRational(1);
203 String[] alpha = new String[] { "alpha" };
204 String[] vars = new String[] { "z" };
205 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
206 GenPolynomial<BigRational> agen = pfac.univariate(0, 4);
207 agen = agen.sum(pfac.fromInteger(4)); // x^4 + 4
208
209 FactorRational engine = new FactorRational();
210
211 FactorsMap<BigRational> F
212 //= engine.baseFactorsAbsoluteSquarefree(agen);
213 //= engine.baseFactorsAbsoluteIrreducible(agen);
214 = engine.baseFactorsAbsolute(agen);
215 //System.out.println("agen = " + agen);
216 //System.out.println("F = " + F);
217
218 boolean t = engine.isAbsoluteFactorization(F);
219 //System.out.println("t = " + t);
220 assertTrue("prod(factor(a)) = a", t);
221 }
222
223
224 /**
225 * Test rational absolute factorization.
226 */
227 public void testRationalAbsoluteFactorization() {
228 TermOrder to = new TermOrder(TermOrder.INVLEX);
229 BigRational cfac = new BigRational(1);
230 String[] vars = new String[] { "x", "y" };
231 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 2, to, vars);
232 GenPolynomial<BigRational> xp = pfac.univariate(0, 2);
233 GenPolynomial<BigRational> yp = pfac.univariate(1, 2);
234 GenPolynomial<BigRational> g = xp.sum(yp); // x^2 + y^2
235 //GenPolynomial<BigRational> g = xp.subtract(yp); // x^2 - y^2
236
237 FactorRational engine = new FactorRational();
238
239 FactorsMap<BigRational> F
240 //= engine.baseFactorsAbsoluteSquarefree(agen);
241 //= engine.baseFactorsAbsoluteIrreducible(agen);
242 = engine.factorsAbsolute(g);
243 //System.out.println("g = " + g);
244 //System.out.println("F = " + F);
245
246 boolean t = engine.isAbsoluteFactorization(F);
247 //System.out.println("t = " + t);
248 assertTrue("prod(factor(a)) = a", t);
249 }
250
251 }