Question

我正在为Android设备开发一个小型Prime数字应用程序并且差不多完成了，但是我希望在优化我的分解类时提供一些帮助。

我仍然遇到一两个问题，在合理的时间内考虑了一些大数字（偶数）。我无法使用Eratosthenes的筛子进行这个特殊的项目，我想我只能在我的物理设备（三星Galaxy S4 Mini）上没有应用程序崩溃的情况下筛选高达1000万。所以我的算法工作如下。我不确定我是否可以制作我实施得更好的Pollard Rho算法。

一旦我确定被测试的数字不是素数或不是素数广场，我会快速进行试验，最多可达10 000，之后如果数字仍未完全考虑，我会使用Pollard Rho在剩下的路上减少它的方法。

我希望能够在2＆gt;范围内对数字进行因子分析。 2 ^ 64

这是一个大约需要15秒的数字的例子256332652145852

它的因子分解是[2,2,1671053,38348971]。

任何帮助都会很高兴。

try {
        long num = Long.valueOf(input);
        if(num == 1) {
            return "1" + " = " + input;
        } else if(num < 1) {
            return "Cannot factor a number less than 1";
        } else if(PrimeNumbers.isPrime(num) == true) {
            return result = num + " is a Prime Number.";
        } else if(isSquare(num) == true && PrimeNumbers.isPrime((long) Math.sqrt(num)) == true) {

            return result = (int) Math.sqrt(num) + "<sup><small>" + 2 + "</small></sup>" + " = " + input;

        } else {
            factors(num, pFactors);
            return result = exponentialForm(pFactors, num) + " = " + input;
        }
    } catch(NumberFormatException e) {
        return result = "Unfortunately the number entered is too large";
    }
}

public static void factors(long n, ArrayList<Long> arr) {

    long number = trialDiv(n, arr);
    if(number > 1) {
        while(true) {
            long divisor = pollard(number, 1);
            if(PrimeNumbers.isPrime(divisor) == true) {
                number /= divisor;
                arr.add(divisor);
                if(PrimeNumbers.isPrime(number) == true) {
                    arr.add(number);
                    break;
                }
            }
        }
    }
}

private static long trialDiv(long n, ArrayList<Long> arr) {

    while(n % 2 == 0) {
        n /= 2;
        arr.add((long) 2);
    }

    for(long i = 3; i < 10000; i += 2) {
        if(PrimeNumbers.isPrime(i) == true) {
            while(n % i == 0) {
                arr.add(i);
                n /= i;
            }
        }
    }
    if(PrimeNumbers.isPrime(n) == true) {
        arr.add(n);
        return 1;
    }
    return n;
}

public static long pollard(long n, long c) {

    long x = 2;
    long y = 2;
    long d = 1;

    while (d == 1) {
        x = g(x, n, c);
        y = g(g(y, n, c), n, c);
        d = gcd(Math.abs(y - x), n);
    }

    if (d == n) {
        return pollard(n, c + 1);
    } else {
        return d;
    }
}

static long g(long x, long n, long c) {
    long g = (((x * x) + c) % n);
    return g;
}

static long gcd(long a, long b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Answer 1

你的波拉德功能还可以但不是很好。您正在使用Pollard的原始算法，但最好使用Brent的变体。但这可能不是你表现缓慢的原因。

您的试验分工功能很慢。检查每个可能的除数的素数是非常昂贵的，并不是必需的。如果用一个复合除法并不重要;分裂总是会失败，但你不要浪费时间检查素性。更好的方法是车轮分解。

Android中的Prime Factorization

1 个答案: