summaryrefslogtreecommitdiff
path: root/libjava/classpath/gnu/java/math/GMP.java
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/classpath/gnu/java/math/GMP.java')
-rw-r--r--libjava/classpath/gnu/java/math/GMP.java474
1 files changed, 474 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/java/math/GMP.java b/libjava/classpath/gnu/java/math/GMP.java
new file mode 100644
index 000000000..4df790a40
--- /dev/null
+++ b/libjava/classpath/gnu/java/math/GMP.java
@@ -0,0 +1,474 @@
+/* gnu.java.math.GMP -- Arbitary precision integers using GMP
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.math;
+
+import gnu.classpath.Pointer;
+
+/**
+ * Implement BigInteger using GMP
+ */
+public final class GMP
+{
+ private Pointer native_ptr;
+ private int refCount = 1;
+
+ public GMP()
+ {
+ super();
+
+ natInitialize();
+ }
+
+ private synchronized void acquireRef()
+ {
+ refCount++;
+ }
+
+ private synchronized void releaseRef()
+ {
+ refCount--;
+ if (refCount == 0)
+ {
+ natFinalize();
+ native_ptr = null;
+ }
+ }
+
+ protected void finalize()
+ {
+ releaseRef();
+ }
+
+
+ public void fromByteArray(byte[] v)
+ {
+ acquireRef();
+ natFromByteArray(v);
+ releaseRef();
+ }
+
+ public void fromBI(GMP x)
+ {
+ acquireRef();
+ x.acquireRef();
+ natFromBI(x.native_ptr);
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void fromLong(long n)
+ {
+ acquireRef();
+ natFromLong(n);
+ releaseRef();
+ }
+
+ public int fromString(String s, int rdx)
+ {
+ acquireRef();
+ int result = natFromString(s, rdx);
+ releaseRef();
+ return result;
+ }
+
+ public void fromSignedMagnitude(byte[] m, boolean isNegative)
+ {
+ acquireRef();
+ natFromSignedMagnitude(m, isNegative);
+ releaseRef();
+ }
+
+ public String toString(int b)
+ {
+ acquireRef();
+ String result = natToString(b);
+ releaseRef();
+ return result;
+ }
+
+ public void toByteArray(byte[] r)
+ {
+ acquireRef();
+ natToByteArray(r);
+ releaseRef();
+ }
+
+ public double doubleValue()
+ {
+ acquireRef();
+ double result = natDoubleValue();
+ releaseRef();
+ return result;
+ }
+
+ public int absIntValue()
+ {
+ acquireRef();
+ int result = natAbsIntValue();
+ releaseRef();
+ return result;
+ }
+
+ public int compare(GMP x)
+ {
+ acquireRef();
+ x.acquireRef();
+ int result = natCompare(x.native_ptr);
+ x.releaseRef();
+ releaseRef();
+ return result;
+ }
+
+ public void add(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natAdd(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void subtract(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natSubtract(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void multiply(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natMultiply(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void quotient(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natQuotient(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void remainder(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natRemainder(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void quotientAndRemainder(GMP x, GMP q, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ q.acquireRef();
+ r.acquireRef();
+ natQuotientAndRemainder(x.native_ptr, q.native_ptr, r.native_ptr);
+ r.releaseRef();
+ q.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void modulo(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natModulo(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void pow(int n, GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natPow(n, r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public void modPow(GMP e, GMP m, GMP r)
+ {
+ acquireRef();
+ e.acquireRef();
+ m.acquireRef();
+ r.acquireRef();
+ natModPow(e.native_ptr, m.native_ptr, r.native_ptr);
+ r.releaseRef();
+ m.releaseRef();
+ e.releaseRef();
+ releaseRef();
+ }
+
+ public void modInverse(GMP m, GMP r)
+ {
+ acquireRef();
+ m.acquireRef();
+ r.acquireRef();
+ natModInverse(m.native_ptr, r.native_ptr);
+ r.releaseRef();
+ m.releaseRef();
+ releaseRef();
+ }
+
+ public void gcd(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natGCD(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void shiftLeft(int n, GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natShiftLeft(n, r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public void shiftRight(int n, GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natShiftRight(n, r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public void abs(GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natAbs(r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public void negate(GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natNegate(r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public int bitLength()
+ {
+ acquireRef();
+ int result = natBitLength();
+ releaseRef();
+ return result;
+ }
+
+ public int bitCount()
+ {
+ acquireRef();
+ int result = natSetBitCount();
+ releaseRef();
+ return result;
+ }
+
+ public void and(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natAnd(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void or(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natOr(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void xor(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natXor(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void andNot(GMP x, GMP r)
+ {
+ acquireRef();
+ x.acquireRef();
+ r.acquireRef();
+ natAndNot(x.native_ptr, r.native_ptr);
+ r.releaseRef();
+ x.releaseRef();
+ releaseRef();
+ }
+
+ public void not(GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natNot(r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public void flipBit(int n, GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natFlipBit(n, r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public int testBit(int n)
+ {
+ acquireRef();
+ int result = natTestBit(n);
+ releaseRef();
+ return result;
+ }
+
+ public void setBit(int n, boolean setIt, GMP r)
+ {
+ acquireRef();
+ r.acquireRef();
+ natSetBit(n, setIt, r.native_ptr);
+ r.releaseRef();
+ releaseRef();
+ }
+
+ public int testPrimality(int certainty)
+ {
+ acquireRef();
+ int result = natTestPrimality(certainty);
+ releaseRef();
+ return result;
+ }
+
+ public int lowestSetBit()
+ {
+ acquireRef();
+ int result = natLowestSetBit();
+ releaseRef();
+ return result;
+ }
+
+ // Native methods .........................................................
+
+ public static native void natInitializeLibrary();
+
+ private native void natInitialize();
+ private native void natFinalize();
+
+ private native void natFromLong(long n);
+ private native void natFromBI(Pointer x);
+ private native void natFromByteArray(byte[] v);
+ private native int natFromString(String s, int rdx);
+ private native void natFromSignedMagnitude(byte[] m, boolean isNegative);
+
+ private native String natToString(int base);
+ private native void natToByteArray(byte[] r);
+ private native int natAbsIntValue();
+ private native double natDoubleValue();
+
+ private native int natCompare(Pointer y);
+ private native void natAdd(Pointer x, Pointer r);
+ private native void natSubtract(Pointer x, Pointer r);
+ private native void natMultiply(Pointer x, Pointer r);
+ private native void natQuotient(Pointer x, Pointer r);
+ private native void natRemainder(Pointer x, Pointer r);
+ private native void natQuotientAndRemainder(Pointer x, Pointer q, Pointer r);
+ private native void natModulo(Pointer m, Pointer r);
+ private native void natPow(int n, Pointer r);
+ private native void natModPow(Pointer e, Pointer m, Pointer r);
+ private native void natModInverse(Pointer x, Pointer r);
+ private native void natGCD(Pointer x, Pointer r);
+ private native int natTestPrimality(int c);
+ private native void natShiftLeft(int n, Pointer r);
+ private native void natShiftRight(int n, Pointer r);
+ private native int natLowestSetBit();
+ private native void natAbs(Pointer r);
+ private native void natNegate(Pointer r);
+ private native int natBitLength();
+ private native int natSetBitCount();
+ private native void natXor(Pointer x, Pointer r);
+ private native void natOr(Pointer x, Pointer r);
+ private native void natAnd(Pointer x, Pointer r);
+ private native void natAndNot(Pointer x, Pointer r);
+ private native void natFlipBit(int n, Pointer r);
+ private native int natTestBit(int n);
+ private native void natSetBit(int n, boolean setIt, Pointer r);
+ private native void natNot(Pointer r);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-18 23:26:31 +0000