Java 可变 BigInteger 类

Question

我正在使用 BigIntegers 进行计算，该计算使用了一个循环，该循环调用 multiply() 大约 1000 亿次，并且从 BigInteger 创建新对象使其非常慢。我希望有人编写或找到了 MutableBigInteger 类。我在 java.math 包中找到了 MutableBigInteger，但它是私有的，当我将代码复制到新类中时，出现了许多错误，其中大多数错误我不知道如何修复。

像 MutableBigInteger 这样的 Java 类有哪些实现允许就地修改值？

Answer 1

他们是否有任何特殊原因导致您无法使用反射来访问该类？

我能够毫无问题地做到这一点，这是代码：

public static void main(String[] args) throws Exception {       
    Constructor<?> constructor = Class.forName("java.math.MutableBigInteger").getDeclaredConstructor(int.class);
    constructor.setAccessible(true);
    Object x = constructor.newInstance(new Integer(17));
    Object y = constructor.newInstance(new Integer(19));
    Constructor<?> constructor2 = Class.forName("java.math.MutableBigInteger").getDeclaredConstructor(x.getClass());
    constructor2.setAccessible(true);
    Object z = constructor.newInstance(new Integer(0));
    Object w = constructor.newInstance(new Integer(0));

    Method m = x.getClass().getDeclaredMethod("multiply", new Class[] { x.getClass(), x.getClass()});
    Method m2 = x.getClass().getDeclaredMethod("mul", new Class[] { int.class, x.getClass()});
    m.setAccessible(true);
    m2.setAccessible(true);

    // Slightly faster than BigInteger
    for (int i = 0; i < 200000; i++) {
        m.invoke(x, y, z);
        w = z;
        z = x;
        x = w;
    }

    // Significantly faster than BigInteger and the above loop
    for (int i = 0; i < 200000; i++) {
        m2.invoke(x, 19, x);
    }

    BigInteger n17 = new BigInteger("17");
    BigInteger n19 = new BigInteger("19");
    BigInteger bigX = n17;

    // Slowest
    for (int i = 0; i < 200000; i++) {
        bigX = bigX.multiply(n19);
    }
}

编辑：
我决定多尝试一下，看来 java.math.MutableBigInteger 的行为并不完全符合您的预期。

当您进行乘法时，它的操作方式有所不同，并且当它在分配给自身时必须增加内部数组的大小时，它会抛出一个很好的异常。我想这是相当值得期待的。相反，我必须交换对象，以便它始终将结果放入不同的 MutableBigInteger 中。经过几千次计算后，反射的开销变得可以忽略不计。 MutableBigInteger 最终确实取得了领先，并且随着操作数量的增加提供了越来越好的性能。如果您使用带有整数基元作为相乘值的“mul”函数，则 MutableBigInteger 的运行速度几乎比使用 BigInteger 快 10 倍。我想这实际上归结为您需要乘以什么值。无论哪种方式，如果您使用 MutableBigInteger 的反射运行此计算“1000 亿次”，它将比 BigInteger 运行得更快，因为内存分配会“更少”，并且它将缓存反射操作，从而消除反射带来的开销。

Answer 2

JScience 有一个名为 LargeInteger 的类，它也是不可变的，但他们声称与 BigInteger 相比，性能显着提高。

http://jscience.org/

APFloat 的 Apint 可能也值得一看。 http://www.apfloat.org/apfloat_java/

Answer 3

我复制了 MutableBigInteger，然后注释掉了一些我不需要的方法体，并

throw new UnsupportedOperationException("...");

在调用时添加了一个 Nice 。

这里是它的外观。

在修订中，您可以看到与原始 java.math.MutableBigInteger 相比发生了什么变化。

我还添加了一些方便的方法，

public void init(long val) {};
public MutableBigInteger(long val) {};
// To save previous value before modifying.
public void addAndBackup(MutableBigInteger addend) {}
// To restore previous value after modifying.  
public void restoreBackup() {}

以下是我的使用方法：

private BigInteger traverseToFactor(BigInteger offset, BigInteger toFactorize, boolean forward) {
    MutableBigInteger mbiOffset = new  MutableBigInteger(offset);
    MutableBigInteger mbiToFactorize = new MutableBigInteger(toFactorize);
    MutableBigInteger blockSize = new MutableBigInteger(list.size);

    if (! MutableBigInteger.ZERO.equals(mbiOffset.remainder(blockSize))) {
        throw new ArithmeticException("Offset not multiple of blockSize");
    }

    LongBigArrayBigList pattern = (LongBigArrayBigList) list.getPattern();

    while (true) {
        MutableBigInteger divisor = new MutableBigInteger(mbiOffset);
        for (long i = 0; i < pattern.size64(); i++) {
            long testOperand = pattern.getLong(i);
            MutableBigInteger.UNSAFE_AUX_VALUE.init(testOperand);
            divisor.addAndBackup(MutableBigInteger.UNSAFE_AUX_VALUE);
            if (MutableBigInteger.ZERO.equals(mbiToFactorize.remainder(divisor))) {
                return divisor.toBigInteger();
            }
            divisor.restoreBackup();
        }

        if (forward) {
            mbiOffset.add(blockSize);
        } else {
            mbiOffset.subtract(blockSize);
        }
        System.out.println(mbiOffset);
    }
}