kredel / java-algebra-system Goto Github PK

View Code? Open in Web Editor NEW

43.0 43.0 9.0 16.03 MB

Java Algebra System (JAS) Project

License: GNU General Public License v2.0

Makefile 0.38% HTML 0.49% Java 98.89% CSS 0.01% Shell 0.17% Propeller Spin 0.03% Ruby 0.04%

java-algebra-system's People

Contributors

Stargazers

Watchers

Forkers

siwiwit strootman dan323 zourzouvillys tubui2 javanevis em3ndez axkr xzllxls

java-algebra-system's Issues

Reduce Javadoc errors

coFactors() method for GreatestCommonDivisor classes

Provide coFactors() methods in GreatestCommonDivisorAbstract. Specification is coFactors(a,b) = [g, a/g, b/g] where g = gcd(a,b). Additionally a method cancel() with cancel(a,b) = [a/g, b/g] where g = gcd(a,b) could be useful.

NullPointerException when parsing expression with denominator 1

Posted on Aug 7, 2014 by Swift Elephant

What steps will reproduce the problem? I don't know if the polynomial ring in 0 variable is supported. Anyway, execute the following test case:

@test public void testNullPointer() {
GenPolynomialRing pfree = new GenPolynomialRing( new BigRational(), new String[] { });
QuotientRing coeff = new QuotientRing(pfree);
coeff.parse("(0|1)");
coeff.parse("(1|1)");
}

We will get the NPE:
java.lang.NullPointerException
at edu.jas.ufd.Quotient.(Quotient.java:105)
at edu.jas.ufd.Quotient.(Quotient.java:77)
at edu.jas.ufd.QuotientRing.parse(QuotientRing.java:380)
at my.TestJas.testNullPointer(TestJas.java:300)

What is the expected output? What do you see instead? No NPE

What version of the product are you using? On what operating system? r4853. Windows 7

Please provide any additional information below.

Sometimes FactorAbstract#factors() never stops

For the variables [a, b, c, d, x] and the poly a * c + a * d * x + b * c * x + b * d * x^2

Sometimes FactorAbstract#factors() gives the correct result (a+b*x)*(c+d*x) and sometimes the calculation never stops?

  FactorAbstract<edu.jas.arith.BigInteger> factorAbstract = FactorFactory 
                  .getImplementation(edu.jas.arith.BigInteger.ONE);
  map = factorAbstract.factors(poly);

Is fraction supported ?

I tried to create x / y while both x and y are GenPolynomial<BigDecimal> objects with x.divide(y). But it gives me 0.

Or do there exist functions that can present (x + y)^-1 ?

Btw, http://krum.rz.uni-mannheim.de/jas/doc/design.html seems not working now..

Remove System.out.println() from PolyUtil and FactorAbstract

Could you please remove System.out.println() from PolyUtil#recursiveDivide and FactorAbstract.java

I'm catching the RuntimeException in my factoring algorithm and don't need the output in Console.
Can you add it to your logger?

Utility Iterable implementation for taylor series coefficients [enhancement]

Can you please add an Iterable<BigRational> (or generic parameter?) implementation for taylor series coefficients calculation of rational polynomials numerator/denominator ?

https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html

the constructor should have a signature similar to this:

SeriesCoefficientsIterator(GenPolynomial<BigRational> numerator, GenPolynomial<BigRational> denominator, String var, BigRational varExpansionValue, int order)

The next() method of the iterator should create the coefficients up to order.

Problems with compareTo() method

For the "symbolic" object hierarchy I'm already using the compareTo() method from the Comparable interface.
This is needed to define an order on all objects.
So if two symbols are compared as a < b it gives true which is wrong in the various JAS algorithms.

Example:

java-algebra-system/src/edu/jas/vector/LinAlg.java

Line 418 in 86164a3

if (absA.compareTo(maxA) > 0) {

Because sometimes the comparison is not "decidable" in this sense, can we set an instance of a new interface in the ring implementations, which is used instead of the compareTo() method?

public interface SymbolicComparable<C extends RingElemen> {

  /** returns true, only if it's assured that this > other for two ring elements; false in all other cases */
  public boolean isGreater(C other);

  /** returns true only if it's assured that   this < other for two ring elements; false in all other cases */
  public boolean isLess(C other);

  /** returns true for example if a numeric evaluation of a symbolic expression evaluates to 0 and false in all other cases */
  public boolean isPossibleZero( );

}

The default method implementation can use the JAS compareTo() method and derived classes can override the behaviour.

Implement decompose method [enhancement]

See the algorithm starting on page 188:

Computer algebra and symbolic computation

Guava TimeLimiter - how to stop also FactorAbstract JAS threads

Implemented a time constrained execution with the Guava TimeLimiter.

How can I ensure, that the JAS threads also stop, if I'm using this framework?
(i.e. FactorAbstract#factorsSquarefreeKronecker writes a lot of ...ti(1234567)... message to console - somewhat randomly? Although the main calculation has already stopped?)

   static public int MAX_THREADS_COUNT = 10;
   final ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS_COUNT);
...

...
   TimeLimiter timeLimiter = SimpleTimeLimiter.create(executor ); 
   EvalCallable work = new EvalCallable(engine);

"Objects of this class are immutable." But the `copy()` method creates a new object on the heap

Often the JAS library objects are described in the Javadoc as "Objects of this class are immutable."

But the copy() method creates a new object on the heap.
The returning of the object itself via return this; would probably more efficient.
Or is there any other reason to do it this way.

Comparing Strings in SolvableIdeal

The strings should be compared with equals:


diff --git a/src/edu/jas/application/SolvableIdeal.java b/src/edu/jas/application/SolvableIdeal.java
index d227721..14ab417 100644
--- a/src/edu/jas/application/SolvableIdeal.java
+++ b/src/edu/jas/application/SolvableIdeal.java
@@ -853,7 +853,7 @@
         String[] rvars = R.getVars();
         String[] tvars = getRing().getVars();
         for (int i = 0; i < rvars.length; i++) {
-            if (rvars[i] != tvars[i]) {
+            if (!rvars[i].equals(tvars[i])) {
                 throw new IllegalArgumentException("no contraction: " + R.toScript() 
                                                  + " of " + getRing().toScript());
             }

How to overwrite BigRational.gcd() ?

In the BigRational#gcd(a,b) method I would like to implement a GCD which gives the greatest rational number r for which all the a/r and b/r are integers and which should be used in the polynomial GCD methods.

java-algebra-system/src/edu/jas/arith/BigRational.java

Line 1146 in 8f040b2

public BigRational gcd(BigRational S) {

Example:

GCD( 2/5, 3/7)  ==>  1/35

Is this possible?
For example with a "global flag" which could be set to true?

See:

edu.jas.application.FactorFactory shadows name of edu.jas.ufd.FactorFactory

The class name edu.jas.application.FactorFactory shadows the simple name of the superclass edu.jas.ufd.FactorFactory.
This can be confusing especially in code completion and debugging.

JAS libs version 2.65851 commit broke compiling in Android Studio

See axkr/symja_android_library#63

Do you have any idea what's the cause of the problem is?

Normalize polynomial results from approximantOfPade?

Can the result poylnomials be "normalized" from the approximantOfPade(), so that the coefficient for x^0 is 0 or 1.

https://en.wikipedia.org/wiki/Pad%C3%A9_approximant#Examples

  public void testQuotientPade001() {
    GenPolynomialRing<BigRational> pr = fac.polyRing();
    GenPolynomial<BigRational> numerator = pr.parse("x^3 + 72 x^2 + 600 x + 720 ");
    GenPolynomial<BigRational> denominator = pr.parse("12 x^2 + 240 x + 720");
    QuotientRing<BigRational> qr = new QuotientRing<BigRational>(pr);

    Quotient<BigRational> p = new Quotient<BigRational>(qr, numerator, denominator);

    QuotientTaylorFunction<BigRational> tf = new QuotientTaylorFunction<BigRational>(p);


    Quotient<BigRational> approximantOfPade =
        PolyUfdUtil.<BigRational>approximantOfPade(fac, tf, BigRational.ZERO, 3, 1);
    System.out.println(approximantOfPade.toString());
    System.out.println("num: " + approximantOfPade.num.toString());
    System.out.println("den: " + approximantOfPade.den.toString());
  }

gives

{ ( -1/192 ) x^3 + 3/16 x^2 + 23/8 x + 15/4  | x + 15/4  }
num: ( -1/192 ) x^3 + 3/16 x^2 + 23/8 x + 15/4 
den: x + 15/4

GenPolynomial#quotientRemainder()

Using JAS 2.6.5961

For symbolic expressions the a.multiply(ci) in GenPolynomial#quotientRemainder() could return 0 or a more complicated expression which must be tested for 0.

Example for a complicated 0 expression: (e/Sqrt[-e/d]+d*Sqrt(-e/d))/Sqrt(-e/d)

In this case the while loop in the code below will never stop.
Could JAS somehow handle this case?
For example with testing for a.isZERO()

        while (!r.isZERO()) {
            ExpVector f = r.leadingExpVector();
            if (f.multipleOf(e)) {
                C a = r.leadingBaseCoefficient();
                ExpVector g = f.subtract(e);
                a = a.multiply(ci);
                q = q.sum(a, g);
                h = S.multiply(a, g);
                r = r.subtract(h);
                assert (!f.equals(r.leadingExpVector())) : "leadingExpVector not descending: " + f;
            } else {
                break;
            }
       }

Is method baseSquarefreeFactors() usable for multivariate polynomials?

Trying to factor polynomial for gaussian integers: ( -1 ) y^12 + x^12 and get an NPE

GenPolynomial internal output: (12,0):long - (0,12):long

java.lang.NullPointerException
	at edu.jas.ufd.SquarefreeFieldChar0.baseSquarefreeFactors(SquarefreeFieldChar0.java:165)
	at edu.jas.ufd.FactorAbstract.baseFactors(FactorAbstract.java:418)
	at edu.jas.ufd.FactorAbstract.factors(FactorAbstract.java:511)
	at org.matheclipse.core.builtin.Algebra.factorComplex(Algebra.java:5063)

See: axkr/symja_android_library#121

Factorization sometimes doesn't stop

Factorization sometimes doesn't stop in JUnit tests
Does someone have an idea why this could happen?

Endless loop in FactorAbstract?

Is there a way to avoid this endless logging.
Seems that JAS don't get out of a loop?

It's difficult to reproduce this case with a unit test. It seems to be dependent on some random values?

Loging:

399270 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorInteger - factorsSquarefreeHensel not applicable or failed, reverting to Kronecker for: a * e * g - c * d * f
399270 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - no multivariate factorization for a * e * g - c * d * f: falling back to Kronecker algorithm in PolyRing(ZZ(),"a,c,d,e,f,g",Order.INVLEX)
399284 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(2000)
399297 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(4000)
399309 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(6000)
399318 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(8000)
399325 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(10000)
399337 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(12000)
399345 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(14000)
399352 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(16000)
399357 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(18000)
399365 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(20000)
399370 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(22000)
399378 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(24000)
399386 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(26000)
399394 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(28000)
399401 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(30000)
399409 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(32000)
399418 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(34000)
399426 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(36000)
399434 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(38000)
399441 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(40000)
...

...
401041 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(702000)
401045 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(704000)
401047 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ndl   = 27, deg(u) = 1
401047 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ulist = [zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1 - 1 , zz1^10 + zz1^9 + zz1^8 + zz1^7 + zz1^6 + zz1^5 + zz1^4 + zz1^3 + zz1^2 + zz1 + 1 ]
401047 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - kr    = zz1^37 - zz1^26
401047 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - u     = a * e * g - c * d * f
401047 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - trial = e * g - c
401051 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(706000)
401057 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(708000)
...

...
401958 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1078000)
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1080000)
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ndl   = 27, deg(u) = 1
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ulist = [zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1 - 1 , zz1^10 + zz1^9 + zz1^8 + zz1^7 + zz1^6 + zz1^5 + zz1^4 + zz1^3 + zz1^2 + zz1 + 1 ]
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - kr    = zz1^37 - zz1^26
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - u     = a * e * g - c * d * f
401964 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - trial = e * g - c
401969 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1082000)
401972 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1084000)
401976 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1086000)
401980 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1088000)
401985 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1090000)
401989 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1092000)
401994 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1094000)
401998 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1096000)
402003 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1098000)
402007 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1100000)
402012 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1102000)
402015 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1104000)
402019 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1106000)
402023 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1108000)
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1110000)
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ndl   = 27, deg(u) = 1
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ulist = [zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1, zz1 - 1 , zz1^10 + zz1^9 + zz1^8 + zz1^7 + zz1^6 + zz1^5 + zz1^4 + zz1^3 + zz1^2 + zz1 + 1 ]
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - kr    = zz1^37 - zz1^26
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - u     = a * e * g - c * d * f
402027 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - trial = e * g - c
402032 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1112000)
402036 WARN  [pool-23241-thread-1] edu.jas.ufd.FactorAbstract - ti(1114000)
...

Should hash attribute now be initialized with -1?

Should the ExpVector hash attribute now be initialized with -1?

java-algebra-system/src/edu/jas/poly/ExpVectorLong.java

Line 175 in cc49aeb

hash = 0; // beware of race condition

Similar method to PolyUtil.integerFromRationalCoefficientsFactor()

Is there a similar method to PolyUtil.integerFromRationalCoefficientsFactor() available for getting reduced GenPolynomial<Complex<BigRational>> polynomials. For example with GaussianIntegers as gcd, lcm?

     public static Object[] method(ComplexRing<BigRational> fac, GenPolynomial<Complex<BigRational>> poly)

Can this also be applied in GreatestCommonDivisor<Complex<BigRational>>#gcd() method?

NoClassDefFoundError: javax.script.ScriptEngineManager under Java 11

Caused by: java.lang.NoClassDefFoundError: javax/script/ScriptEngineManager
at org.apache.logging.log4j.core.script.ScriptManager.(ScriptManager.java:49)
at org.apache.logging.log4j.core.config.AbstractConfiguration.initialize(AbstractConfiguration.java:179)
at org.apache.logging.log4j.core.config.builder.impl.DefaultConfigurationBuilder.build(DefaultConfigurationBuilder.java:174)
at org.apache.logging.log4j.core.config.builder.impl.DefaultConfigurationBuilder.build(DefaultConfigurationBuilder.java:45)
at org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory.getConfiguration(PropertiesConfigurationFactory.java:170)
at org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory.getConfiguration(PropertiesConfigurationFactory.java:48)
at org.apache.logging.log4j.core.config.ConfigurationFactory$Factory.getConfiguration(ConfigurationFactory.java:490)
at org.apache.logging.log4j.core.config.ConfigurationFactory$Factory.getConfiguration(ConfigurationFactory.java:460)
at org.apache.logging.log4j.core.config.ConfigurationFactory.getConfiguration(ConfigurationFactory.java:256)
at org.apache.logging.log4j.core.LoggerContext.reconfigure(LoggerContext.java:561)
at org.apache.logging.log4j.core.LoggerContext.reconfigure(LoggerContext.java:578)
at org.apache.logging.log4j.core.LoggerContext.start(LoggerContext.java:214)
at org.apache.logging.log4j.core.impl.Log4jContextFactory.getContext(Log4jContextFactory.java:145)
at org.apache.logging.log4j.core.impl.Log4jContextFactory.getContext(Log4jContextFactory.java:41)
at org.apache.logging.log4j.LogManager.getContext(LogManager.java:182)
at org.apache.logging.log4j.LogManager.getLogger(LogManager.java:455)
at edu.jas.poly.TermOrder.(TermOrder.java:39)

Class file has wrong version 61.0, should be 55.0

Is the latest JAS JAR compiled with Java 17? In Maven I get the error:
Class file has wrong version 61.0, should be 55.0

Can we have a JAR compiled with JAVA 11?

From the pom.xml I assume that Java 8 can also work?

See:

https://javaalmanac.io/bytecode/versions/

Factorization stops after some time

Maybe related to #12 ?

This example stops (or gets very slow?) after random throughput.

Every run it uses the same polynomial example as above.

import java.util.SortedMap;

import edu.jas.poly.GenPolynomial;
import edu.jas.poly.GenPolynomialRing;
import edu.jas.poly.TermOrder;
import edu.jas.ufd.FactorAbstract;
import edu.jas.ufd.FactorFactory;

public class TestFactor {

  public static void main(String[] args) { 
    String str =
        "-2*m1*m2*u1*u2+m1*m2*u2^2-m2^2*u2^2+2*m1*m2*u1*v2+2*m2^2*u2*v2-m1*m2*v2^2-m2^2*v2^2";

    String[] vars = new String[] {"m1", "m2", "u1", "u2", "v2"};
    GenPolynomialRing<edu.jas.arith.BigInteger> fac;
    fac =
        new GenPolynomialRing<edu.jas.arith.BigInteger>(
            edu.jas.arith.BigInteger.ZERO, vars.length, new TermOrder(TermOrder.INVLEX), vars);

    GenPolynomial<edu.jas.arith.BigInteger> poly = fac.parse(str);
    for (int i = 0; i < 100000; i++) {
      System.out.println("Run: " + i + " -" + poly.toString());
      FactorAbstract<edu.jas.arith.BigInteger> factorAbstract =
          FactorFactory.getImplementation(edu.jas.arith.BigInteger.ZERO);
      SortedMap<GenPolynomial<edu.jas.arith.BigInteger>, Long> map = factorAbstract.factors(poly);
      System.out.println("Factors: " + map.toString());
    }
  }
}

How to calculate the value of polynomial after assigning values to variables ?

        GenPolynomial<BigInteger> pol;
        pol = ring.parse("3 x1^2 x3^4 + 7 x2^5 - 61");

What should I do to calculate the value of pol when I get x1 = 1, x2 = 2, x3 = 3 ?

I can't find the solution in the Examples.java. Maybe I missed something? Thanks

Factor[2y^6- xy^3 -3*x^2] doesn't always return a factorization

Can the case Factor[2*y^6- x*y^3 -3*x^2] be made more reliable in returning the solution (x+y^3)*(-3*x+2*y^3) ?

In most of the cases it returns -3*x^2-x*y^3+2*y^6

See some random execution with JAS logs:

>> Factor[2*y^6- x*y^3 -3*x^2]
In[1]:= Factor[2*y^6- x*y^3 -3*x^2]
4761 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [371], dei = []
4765 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
4953 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [371], dei = []
4953 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
4957 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
5577 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [371], dei = []
5577 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = ( -3 ) x^2 - y^3 * x + 2 y^6, prr = 2  y^6 - x y^3 - 3 x^2 , lprr = 2 , lfacs = []
5577 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
5990 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [371], dei = []
5990 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = ( -3 ) x^2 - y^3 * x + 2 y^6, prr = 2  y^6 - x y^3 - 3 x^2 , lprr = 2 , lfacs = []
5991 WARN  [main] edu.jas.ufd.FactorInteger - factorsSquarefreeHensel not applicable or failed, reverting to Kronecker for: 2 y^6 - x * y^3 - 3 x^2
5992 WARN  [main] edu.jas.ufd.FactorAbstract - no multivariate factorization for 2 y^6 - x * y^3 - 3 x^2: falling back to Kronecker algorithm in PolyRing(ZZ(),"x,y",Order.INVLEX)
Out[1]= -3*x^2-x*y^3+2*y^6
>> Factor[2*y^6- x*y^3 -3*x^2]
In[2]:= Factor[2*y^6- x*y^3 -3*x^2]
10393 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-371], dei = []
10393 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
10507 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-371], dei = []
10507 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
10508 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
10891 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-370], dei = []
10891 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = ( -3 ) x^2 - y^3 * x + 2 y^6, prr = 2  y^6 - x y^3 - 3 x^2 , lprr = 2 , lfacs = []
10891 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
10901 WARN  [main] edu.jas.ufd.FactorInteger - end notLucky loop, trial parts = 4
10908 WARN  [main] edu.jas.ufd.FactorInteger - de-optimized polynomials: [2 y^3 - 3 x, y^3 + x]
Out[2]= (x+y^3)*(-3*x+2*y^3)
>> Factor[2*y^6- x*y^3 -3*x^2]
In[3]:= Factor[2*y^6- x*y^3 -3*x^2]
15669 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-371], dei = []
15669 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
15777 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-371], dei = []
15778 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = 2 y^6 - x * y^3 - 3 x^2, prr = ( ( -3 )  ) x^2 - y^3 x + 2 y^6 , lprr = ( -3 ) , lfacs = []
15778 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
16119 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [371], dei = []
16119 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = ( -3 ) x^2 - y^3 * x + 2 y^6, prr = 2  y^6 - x y^3 - 3 x^2 , lprr = 2 , lfacs = []
16119 WARN  [main] edu.jas.ufd.FactorInteger - optimized ring: BigInteger( y,x ) INVLEX , original ring: BigInteger( x,y ) INVLEX 
16478 WARN  [main] edu.jas.ufd.FactorInteger - found         points   : V = [-370], dei = []
16479 WARN  [main] edu.jas.ufd.FactorInteger - no evaluation point for: P = ( -3 ) x^2 - y^3 * x + 2 y^6, prr = 2  y^6 - x y^3 - 3 x^2 , lprr = 2 , lfacs = []
16479 WARN  [main] edu.jas.ufd.FactorInteger - factorsSquarefreeHensel not applicable or failed, reverting to Kronecker for: 2 y^6 - x * y^3 - 3 x^2
16479 WARN  [main] edu.jas.ufd.FactorAbstract - no multivariate factorization for 2 y^6 - x * y^3 - 3 x^2: falling back to Kronecker algorithm in PolyRing(ZZ(),"x,y",Order.INVLEX)
Out[3]= -3*x^2-x*y^3+2*y^6

BTW: I switched off the internal cache for results from Factor to get always a new execution.

kredel / java-algebra-system Goto Github PK

java-algebra-system's People

Contributors

Stargazers

Watchers

Forkers

java-algebra-system's Issues

Recommend Projects

Recommend Topics

Recommend Org

Jobs