Java Veränderlich BigInteger-Klasse

Ist Ihr irgendeinen bestimmten Grund, warum Sie nicht verwenden Sie reflektion, um Zugriff auf die Klasse?

War ich in der Lage zu tun, ohne Probleme, hier ist der code:

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);
    }
}

Bearbeiten:
Ich entschied mich zu spielen, um mit ein bisschen mehr, es scheint, dass java.math.MutableBigInteger verhält sich nicht genau so, wie man es erwarten würde.

Arbeitet es sich anders, wenn Sie sich vermehren und wird es werfen eine schöne Ausnahme, wenn es um erhöhen Sie die Größe des internen Arrays bei der Zuordnung zu sich selbst. Etwas, was ich denke, ist Fair zu erwarten. Statt dessen habe ich zu tauschen, um die Objekte so, dass Sie immer die Speicherung des Ergebnisses in eine andere MutableBigInteger. Nach ein paar tausend Berechnungen der Aufwand aus der Reflexion vernachlässigbar. MutableBigInteger hat am Ende, ziehen Sie weiter und bietet immer bessere Leistung als die Anzahl der Operationen erhöht. Wenn Sie verwenden die 'mul' - Funktion mit einem integer-primitive als der Wert, der multipliziert mit der MutableBigInteger läuft fast 10-mal schneller als mit BigInteger. Ich denke, es ist wirklich darauf an, was Wert, den Sie brauchen, um zu multiplizieren mit. Entweder Weg, wenn Sie lief dieser Berechnung "100 Milliarden mal" mit Reflexion mit MutableBigInteger, es würde schneller laufen als BigInteger, weil es wäre "weniger" memory allocation und cache würde die reflektierende Operationen, entfernen von overhead, von Reflexion.

Ich kopiert MutableBigInteger, dann auskommentiert werden einige Methoden' stellen, die ich dind nicht brauchen, hinzufügen von einen schönen

throw new UnsupportedOperationException("...");

wenn Sie aufgerufen wird.

hier ist, wie es aussieht.

In Revisionen können Sie sehen, was sich von der ursprünglichen java.math.MutableBigInteger.

Habe ich auch noch einige Komfort-Methoden,

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() {}

Hier ist, wie ich es benutzt habe:

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);
    }
}