Use EllipticCurveMethod in CombinedFactorAlgorithm.factor()

[axkr]

Use de.tilman_neumann.jml.factor.ecm.EllipticCurveMethod in CombinedFactorAlgorithm.factor()

[TilmanNeumann]

Class EllipticCurveMethod does not look very reliable yet. I am working on tests.

[axkr]

@TilmanNeumann does it help doing tests, if I already update the Symja project or better waiting for an official release?

BTW: which method is now best suited to factor a Java int value?

[TilmanNeumann]

If you are happy with the stability of your current implementation, then I would wait, because my latest changes had hardly an influence on performance. The point is that ECM is quite tolerant against spurious bugs; if a bug only appears in 1% of curves then the overall performance will not suffer much.

The fastest algorithm to factor ints depends on the nature of the test numbers. For arbitrary numbers, TDiv31Barrett is the best choice for N up to 31 bits. For semiprimes, Hart_Squarefree is the fastest algorithm for N from 27 to 31 bit.

[axkr]

What function must I call to get the simple small prime factors?

This example returns 22 as a factor, how can I get 2 and 11 into the map?

	public static void main(String[] args) {
		TDiv31Barrett tdiv=new TDiv31Barrett();
		SortedMultiset<BigInteger> tdivFactors = tdiv.factor(BigInteger.valueOf(990));
		for (Map.Entry<BigInteger, Integer> entry : tdivFactors.entrySet()) {
			System.out.println("Key:"+entry.getKey()+" Value:"+ entry.getValue());
		}
	}

BTW shouldn't there be a method for int values to avoid the overhead of BigIntegers?

[axkr]

Ok, I think it should work like this?

	public static void main(String[] args) {
		TDiv31Barrett tdiv = new TDiv31Barrett();

		int value = 990;
		int prime = tdiv.findSingleFactor((int) value);
		while (true) {
			prime = tdiv.findSingleFactor((int) value);
			value /= prime;
			if (prime != 1) {
				System.out.println("Key:" + prime);
			} else {
				break;
			}
		}
		if (prime != 1) {
			SortedMultiset<BigInteger> tdivFactors = tdiv.factor(BigInteger.valueOf(value));
			for (Map.Entry<BigInteger, Integer> entry : tdivFactors.entrySet()) {
				System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());
			}
		}
	}

[axkr]

From my experience this JAS algorithm is a quite fast algorithm for long values up to a BETA limit:

https://github.com/kredel/java-algebra-system/blob/8f040b29fc4faaa2ac6d12b993769aa6bb78fd66/src/edu/jas/arith/PrimeInteger.java#L377

Do you have a corresponding algorithm in your library?

[TilmanNeumann]

The findSingleFactor() method is mostly of interest if you know that the test numbers are semiprimes. In any other case I'ld use the factor() method. I admit that for some small range algorithms the factor() method is not well-implemented, but TDivBarrett31 overrides it and should be pretty fast in the mentioned number range.

I guess that BETA is something near to 2^61 or 2^62. My best algorithm in that range is TinyEcm64. PollardRhoBrentMontgomery64 is the second best algorithm in that range. Hart_Fast2Mult and Lehman_CustomKOrder are the best algorithms from something like 35 to 48 bits.

[axkr]

TDiv31Barrett#.factor(BigInteger.valueOf(990)) returns 22 as a factor?

[TilmanNeumann]

Good spot. Obviously my Barrett division does not work with p=2. Now I check the lsb which is faster anyway.

[TilmanNeumann]

Thanks for finding that one!

[TilmanNeumann]

My inital integration of Dario Alpern's ECM is finished. I took a very conservative (say, small) number of curves to run before invoking SIQS/PSIQS because the original settings were very slow for hard semi-primes.

This work required to introduce a more complex but more powerful interface to "find some factors". Feedback is very welcome.

There are a few minor topics I'll work on in the sequel, like passing the amount of trial division that has already been done.

[axkr]

Can you show some simple examples for factoring:

For simplicity let's say I want to factor the number 990.
How should I implement this now?

[axkr]

I'm using now this algorithm. It seems to be slower in my JUnit test suite.
Especially testMultiplicativeOrder() in

• https://github.com/axkr/symja_android_library/blob/master/symja_android_library/matheclipse-io/src/test/java/org/matheclipse/io/system/LowercaseTestCase.java

Does it make sense to search for the bottleneck or should I use some different coding?

public static void factorInteger(final BigInteger val, SortedMap<BigInteger, Integer> map) {
    CombinedFactorAlgorithm factorizer;
    final int cores = Runtime.getRuntime().availableProcessors();
    if (Config.JAVA_UNSAFE) {
      factorizer = new CombinedFactorAlgorithm(cores / 2 + 1, true);
    } else {
      factorizer = new CombinedFactorAlgorithm(1, false);
    }
    //    CombinedFactorAlgorithm cfa = new CombinedFactorAlgorithm(1);
    SortedMultiset<BigInteger> set = factorizer.factor(val);
    for (Map.Entry<BigInteger, Integer> entry : set.entrySet()) {
      map.put(entry.getKey(), entry.getValue());
    }
    return;
  }

[TilmanNeumann]

Your coding looks ok. This is a first shot, it is quite possible I overlooked somthing.

Much depends on the kind of test numbers. Which kind of numbers is your JUnit test suite testing?

[axkr]

Can you support special `SortedMap' implementations that can throw exceptions, if a number is not square free or not a prime power?

• https://github.com/axkr/symja_android_library/blob/3ba5b9aa241ab1377094468b3a80fff0141a1535/symja_android_library/matheclipse-core/src/main/java/org/matheclipse/core/numbertheory/Primality.java#L54
• https://github.com/axkr/symja_android_library/blob/3ba5b9aa241ab1377094468b3a80fff0141a1535/symja_android_library/matheclipse-core/src/main/java/org/matheclipse/core/numbertheory/Primality.java#L40