| /* gnu_java_math_GMP.c -- Native MPI implemenetation over GNU MP |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is a 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 of the License, 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; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, 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. */ |
| |
| #include <limits.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif /* HAVE_CONFIG_H */ |
| |
| #include "gnu_java_math_GMP.h" |
| #include <jcl.h> |
| |
| #if defined(HAVE_GMP_H) |
| #include <gmp.h> |
| #endif /* defined(HAVE_GMP_H) */ |
| |
| #if defined(WITH_GNU_MP) |
| #else |
| #warning GNU MP not available or wanted! |
| #warning Invocation of natXXX() methods will raise an exception |
| #endif |
| |
| /* |
| * This is the implementation of the native BigInteger$NativeMPI methods which |
| * use the GNU MP (GMP) library. |
| * |
| * In all the Java non-statically declared native methods, the second argument, |
| * an instance of jobject, refers to the current NativeMPI instance; i.e. |
| * "this" in Java parlance. The corresponding allocated data structure |
| * representing the GMP's counter-part is pointed-to by the pointer stored in a |
| * transient java field named "native_ptr". The first thing these methods do is |
| * (a) access that field with a JNI GetObjectField() call to obtain the |
| * reference to the gnu.classpath.Pointer subclass instance, then (b) obtain |
| * the native GMP pointer (an mpz_ptr), in order to perform their job; e.g. |
| * |
| * JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)) |
| * |
| * For static methods the second argument, an instance of jclass, is almost |
| * always unused --except when initializing the library, which is the only time |
| * we get hold of the native pointer field. |
| * |
| * This code was written and tested with GNU MP version 4.1.2. More recent |
| * versions of that library offer more operations; e.g. in the implementation |
| * of the method Java_java_math_BigInteger_00024NativeMPI_natFlipBit, mpz_combit() |
| * should be used with GNU MP versions later than 4.2. As a consequence, this |
| * code should be reviewed, from time to time, to use newer features of the GNU |
| * MP library. |
| */ |
| |
| static jfieldID native_ptr; |
| |
| #ifdef DEBUG |
| #define TRACE(msg) fprintf (stderr, "%s(%s:%d) -- %s\n", __FUNCTION__, __FILE__, __LINE__, msg) |
| #else |
| #define TRACE(msg) |
| #endif |
| |
| #define throw_config_exception(env) JCL_ThrowException (env, "java/lang/Error", "GNU MP was not specified/found by configure") |
| |
| /* |
| * Initialize the native library. Specifically this method: |
| * |
| * a. Pass NULLs to the mp_set_memory_functions implying that GMP should use |
| * malloc, realloc and free for memory allocation, and if they fail GMP |
| * will print a message to the standard error output and terminates the |
| * program. |
| * b. Find out and store the reference to the NativeMPI class's 'native_ptr' |
| * field. This is done so later in the method invocations we can access that |
| * field and acquire the native value associated with that Pointer instance. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natInitializeLibrary (JNIEnv *env, |
| jclass nativeMPI) |
| { |
| #if defined(WITH_GNU_MP) |
| TRACE("Loading GMP-based BigInteger native library"); |
| mp_set_memory_functions (NULL, NULL, NULL); |
| native_ptr = (*env)->GetFieldID (env, nativeMPI, "native_ptr", |
| "Lgnu/classpath/Pointer;"); |
| TRACE("Loaded GMP-based BigInteger native library"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) nativeMPI; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * Allocate and initialize the data structure for an instance of a NativeMPI. |
| * |
| * @param this an instance of NativeMPI. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natInitialize(JNIEnv *env, jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_malloc (env, sizeof (mpz_t)); |
| /* initialize --GMP sets the value to zero. */ |
| mpz_init (_this); |
| /* instantiate the Pointer instance for this NativeMPI. */ |
| jobject native_ptr_fld = JCL_NewRawDataObject (env, _this); |
| /* ... and assign it to the native_ptr field. */ |
| (*env)->SetObjectField (env, this, native_ptr, native_ptr_fld); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * Clear and free the data structure for an instance of a NativeMPI. |
| * |
| * @param this an instance of NativeMPI. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFinalize(JNIEnv *env, jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| if (_this != NULL) |
| { |
| mpz_clear (_this); |
| free (_this); |
| _this = NULL; |
| } |
| else |
| { |
| TRACE("WARNING: Already cleared + freed"); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| |
| /* |
| * @param this an instance of NativeMPI. On exit, this will have a value of n. |
| * @param n a Java long primitive value. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFromLong(JNIEnv *env, jobject this, |
| jlong n) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| /* the size of jlong (64-bit) is either the same as a long, or that of a long long. |
| * if it's the former, we use as is. */ |
| if (sizeof (jlong) == sizeof (long)) |
| { |
| mpz_set_si (_this, (signed long)n); |
| } |
| else |
| { |
| /* ...otherwise, we operate on the two halves of the long long, each half |
| * being 32-bit wide. for simplicity, we work with positive |
| * values negating, if necessary, the final outcome. |
| */ |
| const int isnegative = n < 0 ? 1 : 0; |
| if (isnegative) |
| { |
| n = -n; |
| } |
| mpz_set_ui (_this, (unsigned long)(((unsigned long long)n) >> 32)); |
| mpz_mul_2exp (_this, _this, 32); /* shift left by 32 bits */ |
| mpz_add_ui (_this, _this, (unsigned long)n); |
| if (isnegative) |
| { |
| mpz_neg (_this, _this); |
| } |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) n; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. On exit, this will have the same |
| * value as x. |
| * @param x an instance of a NativeMPI's Pointer. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFromBI(JNIEnv *env, jobject this, |
| jobject x) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| mpz_srcptr _x; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| mpz_set (_this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. On exit, this will have the value |
| * represented by the v Java byte array (in 2's complement with most |
| * significant byte at index position 0). The sign is implied by the |
| * value of the most significant byte. |
| * @param v a Java byte array containing the byte representation, in 2's |
| * complement of the signed value to assign to this. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFromByteArray(JNIEnv *env, |
| jobject this, |
| jbyteArray v) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| jbyte *_v; |
| unsigned long b; |
| int vlength, isnegative, i; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _v = (*env)->GetByteArrayElements (env, v, NULL); |
| vlength = (*env)->GetArrayLength (env, v); |
| b = (unsigned long)(_v[0] & 0xFF); |
| isnegative = (b > 0x7F) ? 1 : 0; |
| mpz_set_ui (_this, 0); |
| for (i = 0; i < vlength; i++) |
| { |
| mpz_mul_2exp (_this, _this, 8); /* shift left 8 positions. */ |
| b = (unsigned long)(_v[i] & 0xFF); |
| b = (isnegative) ? ~b : b; |
| mpz_add_ui (_this, _this, (unsigned long)(b & 0xFF)); |
| } |
| (*env)->ReleaseByteArrayElements (env, v, _v, JNI_ABORT); |
| if (isnegative) |
| { |
| mpz_add_ui (_this, _this, 1); |
| mpz_neg (_this, _this); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) v; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. On exit, this will have the value |
| * represented by the s Java string. |
| * @param s a Java string containing, a possibly signed, value to assign to |
| * this. |
| * @param rdx the base in which the symbols, in s, are represented. |
| * @return 0 if the entire string is a valid number in base rdx. Otherwise it |
| * returns -1. |
| * |
| * Implementation note: |
| * While the GMP library is more tolerant in what it accepts as parameter values |
| * for conversions from strings, the BigInteger code, which calls this method, |
| * ensures that the contract described in the RI's documentation is respected; |
| * e.g. no white spaces in the middle, limited valid radix values, etc... |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natFromString(JNIEnv *env, |
| jobject this, jstring s, |
| jint rdx) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| const char *_s; |
| int result; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _s = (*env)->GetStringUTFChars (env, s, NULL); |
| result = mpz_set_str (_this, _s, (int)rdx); |
| JCL_free_cstring (env, s, _s); |
| TRACE("end"); |
| return (result); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) s; |
| (void) rdx; |
| throw_config_exception(env); |
| return (-1); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. On exit, this will have the value |
| * represented by the m Java byte array (most significant byte at |
| * index position 0). It will be positive, or negative, depending on |
| * the value of isnegative. |
| * @param m a Java byte array containing the byte representation of the |
| * absolute value (most significant byte being at index position 0) |
| * to assign to this. |
| * @param isnegative true if this should be negative and false if it should |
| * be positive. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFromSignedMagnitude(JNIEnv *env, |
| jobject this, |
| jbyteArray m, |
| jboolean isnegative) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this; |
| jbyte *_m; |
| int mlength, i; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _m = (*env)->GetByteArrayElements (env, m, NULL); |
| mlength = (*env)->GetArrayLength (env, m); |
| mpz_set_ui (_this, 0); |
| for (i = 0; i < mlength; i++) |
| { |
| mpz_mul_2exp (_this, _this, 8); |
| mpz_add_ui (_this, _this, (unsigned long)(_m[i] & 0xFF)); |
| } |
| (*env)->ReleaseByteArrayElements (env, m, _m, JNI_ABORT); |
| if (isnegative == JNI_TRUE) |
| { |
| mpz_neg (_this, _this); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) m; |
| (void) isnegative; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the base in which to represent this. |
| * @return the Java string representing the value of this in base n. |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_gnu_java_math_GMP_natToString(JNIEnv *env, jobject this, |
| jint n) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| char *cstr; |
| jstring result; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| cstr = mpz_get_str (NULL, (int)n, _this); |
| result = (*env)->NewStringUTF (env, cstr); |
| free (cstr); |
| TRACE("end"); |
| return (result); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| throw_config_exception(env); |
| return (NULL); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this a non-ZERO instance of NativeMPI. |
| * |
| * output: |
| * @param r a Java byte array which shall contain the byte representation of |
| * this. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natToByteArray(JNIEnv *env, |
| jobject this, |
| jbyteArray r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_t _w; /* a temporary work mpi */ |
| jbyte *_r; |
| int rlength, sign, i; |
| unsigned long b; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (*env)->GetByteArrayElements (env, r, NULL); |
| rlength = (*env)->GetArrayLength (env, r); |
| mpz_init (_w); |
| /* if this is negative set w to its 2's complement otherwise use as is. */ |
| sign = mpz_sgn (_this); |
| if (sign == 1) |
| { |
| mpz_set (_w, _this); |
| } |
| else |
| { |
| mpz_neg (_w, _this); |
| mpz_sub_ui (_w, _w, 1); |
| } |
| /* _w SHOULD be >= 0. |
| * start filling the array starting from the least significant byte. */ |
| for (i = rlength; --i >= 0; ) |
| { |
| b = mpz_tdiv_q_ui (_w, _w, 256); |
| b = (sign == -1) ? ~b : b; |
| _r[i] = (unsigned long)(b & 0xFF); |
| } |
| (*env)->ReleaseByteArrayElements (env, r, _r, JNI_COMMIT); |
| /* if _w > 0 the byte array was short. */ |
| if (mpz_cmp_ui (_w, 0) > 0) |
| { |
| TRACE("WARNING: byte array is too short"); |
| } |
| mpz_clear (_w); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @return the "int" value (least significant 32 bits) of the absolute value |
| * of this NativeMPI. The calling code MUST handle the sign. We do |
| * this so we can use the same method when computing the "long" value |
| * as well. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natAbsIntValue(JNIEnv *env, |
| jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jint)mpz_get_ui (_this)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) s; |
| throw_config_exception(env); |
| return (-1); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @return the, eventually truncated, double value of this NativeMPI. |
| */ |
| JNIEXPORT jdouble JNICALL |
| Java_gnu_java_math_GMP_natDoubleValue(JNIEnv *env, |
| jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jdouble)mpz_get_d (_this)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| return (0.0); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this a NativeMPI instance. |
| * @param x an instance of NativeMPI's Pointer. |
| * @return -1, 0, +1 if x is respectively less than, equal to, or greater |
| * than y. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natCompare(JNIEnv *env, jobject this, |
| jobject x) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_ptr _this, _x; |
| int res; |
| |
| TRACE("begin"); |
| _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_ptr)JCL_GetRawData (env, x); |
| res = mpz_cmp (_this, _x); |
| TRACE("end"); |
| if (res == 0) |
| return ((jint)0); |
| else if (res < 0) |
| return ((jint)-1); |
| else |
| return ((jint)1); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) x; |
| (void) y; |
| throw_config_exception(env); |
| return (0); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this + x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natAdd(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_add (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this - x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natSubtract(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_sub (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this * x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natMultiply(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_mul (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this div x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natQuotient(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_tdiv_q (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this mod x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natRemainder(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_tdiv_r (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param q a NativeMPI's Pointer such that q = this div x. |
| * @param r a NativeMPI's Pointer such that r = this mod x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natQuotientAndRemainder(JNIEnv *env, |
| jobject this, |
| jobject x, |
| jobject q, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _q, _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _q = (mpz_ptr)JCL_GetRawData (env, q); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_tdiv_qr (_q, _r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) q; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this mod x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natModulo(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_mod (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n a non-negative number to raise this to. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this ** n. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natPow(JNIEnv *env, jobject this, |
| jint n, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_pow_ui (_r, _this, (unsigned long)n); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param e an instance of NativeMPI's Pointer. |
| * @param m another instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = (this**e) mod m. |
| * |
| * @throws java.lang.ArithmeticException if e is negative and (1 / this) mod m |
| * has no multiplicative inverse. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natModPow(JNIEnv *env, jobject this, |
| jobject e, jobject m, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _e, _m; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _e = (mpz_srcptr)JCL_GetRawData (env, e); |
| _m = (mpz_srcptr)JCL_GetRawData (env, m); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| /* the documentation of mpz_powm(rop, b, e, m) states that it: "Set rop to |
| * (b raised to e) modulo m. Negative e is supported if an inverse b^-1 mod m |
| * exists.... If an inverse doesn't exist then a divide by zero is raised." |
| * to work around this case we use the same code as in the pure java class; |
| * i.e.: |
| * if (e.isNegative()) |
| * return this.modInverse(m).modPow(e.negate(), m); */ |
| if (mpz_sgn (_e) == -1) |
| { |
| mpz_t _w; /* a temporary work mpi */ |
| const int res = mpz_invert (_r, _this, _m); |
| if (res == 0) |
| { |
| JCL_ThrowException (env, "java/lang/ArithmeticException", |
| "No multiplicative inverse modulo the designated number exists"); |
| } |
| mpz_init (_w); |
| mpz_neg (_w, _e); |
| mpz_powm (_r, _r, _w, _m); |
| mpz_clear (_w); |
| } |
| else |
| { |
| mpz_powm (_r, _this, _e, _m); |
| } |
| |
| while (mpz_sgn (_r) == -1) |
| { |
| mpz_add (_r, _r, _m); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) e; |
| (void) m; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param m an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = (1 / this) mod m. |
| * @throws java.lang.ArithmeticException if (1 / this) mod m has no |
| * multiplicative inverse. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natModInverse(JNIEnv *env, |
| jobject this, |
| jobject m, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _m; |
| mpz_ptr _r; |
| int res; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _m = (mpz_srcptr)JCL_GetRawData (env, m); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| res = mpz_invert (_r, _this, _m); |
| if (res == 0) |
| { |
| JCL_ThrowException (env, "java/lang/ArithmeticException", |
| "No multiplicative inverse modulo the designated number exists"); |
| } |
| |
| while (mpz_sgn (_r) == -1) |
| { |
| mpz_add (_r, _r, _m); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r is the GCD of this and x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natGCD(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_gcd (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n number of Miller-Rabin tests to conduct. |
| * @return 2 if this is definitely prime. Returns 1 if this is probably prime |
| * (without being certain). Finally, returns 0 if this is definitely |
| * composite. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natTestPrimality(JNIEnv *env, |
| jobject this, jint n) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jint)mpz_probab_prime_p (_this, (int)n)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| throw_config_exception(env); |
| return (0); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the non-negative number of positions to shift right this by. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this * 2**n. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natShiftLeft(JNIEnv *env, jobject this, |
| jint n, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_mul_2exp (_r, _this, (unsigned long)n); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the non-negative number of positions to shift left this by. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = floor(this / 2**n). |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natShiftRight(JNIEnv *env, |
| jobject this, jint n, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_fdiv_q_2exp (_r, _this, (unsigned long)n); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @return the 0-based index of the lowest significant bit set (to 1) in this. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natLowestSetBit(JNIEnv *env, |
| jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jint)mpz_scan1 (_this, 0)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| return (-1); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = abs(x). |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natAbs(JNIEnv *env, jobject this, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_abs (_r, _this); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = -x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natNegate(JNIEnv *env, jobject this, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_neg (_r, _this); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @return the number of bits needed to represent this. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natBitLength(JNIEnv *env, jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jint)mpz_sizeinbase (_this, 2)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| return (-1); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. It MUST be >= ZERO. |
| * @return the number of bits set (to 1) in this. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natSetBitCount(JNIEnv *env, |
| jobject this) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _bi; |
| unsigned long res = 0; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| switch (mpz_sgn (_this)) |
| { |
| case -1: |
| /* initialize --GMP sets the value to zero. */ |
| _bi = (mpz_ptr)JCL_malloc (env, sizeof (mpz_t)); |
| mpz_init (_bi); |
| mpz_neg (_bi, _this); |
| res = mpz_popcount (_bi); |
| mpz_clear (_bi); |
| free (_bi); |
| break; |
| case 0: |
| res = 0; |
| break; |
| case 1: |
| res = mpz_popcount (_this); |
| default: |
| JCL_ThrowException (env, "java/lang/Error", |
| "Unexpected sign value for a native MPI"); |
| } |
| TRACE("end"); |
| return ((jint)res); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| throw_config_exception(env); |
| return (ULONG_MAX); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this ^ x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natXor(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_xor (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this | x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natOr(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_ior (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this & x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natAnd(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_and (_r, _this, _x); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param x an instance of NativeMPI's Pointer. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = this & ~x. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natAndNot(JNIEnv *env, jobject this, |
| jobject x, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this, _x; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _x = (mpz_srcptr)JCL_GetRawData (env, x); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_com (_r, _x); |
| mpz_and (_r, _this, _r); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) x; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the 0-based index position of the bit to flip in this. n MUST be |
| * greater than, or equal to 0. |
| * |
| * output: |
| * @param r a copy of this NativeMPI's Pointer with its n-th bit flipped. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natFlipBit(JNIEnv *env, jobject this, |
| jint n, jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_set (_r, _this); |
| /* GNU MP versions earlier than 4.2 do not define this method: |
| * mpz_combit (_r, (unsigned long)n); */ |
| if (mpz_tstbit (_r, (unsigned long)n) == 1) |
| { |
| mpz_clrbit (_r, (unsigned long)n); |
| } |
| else |
| { |
| mpz_setbit (_r, (unsigned long)n); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the 0-based index position of the bit to test in this. n MUST be |
| * greater than, or equal to 0. |
| * @return +1, or -1 depending on whether the n-th bit in this is set or not |
| * respectively. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_gnu_java_math_GMP_natTestBit(JNIEnv *env, jobject this, |
| jint n) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| TRACE("end"); |
| return ((jint)mpz_tstbit (_this, (unsigned long)n)); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| throw_config_exception(env); |
| return (-1); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * @param n the 0-based index position of the bit to set, or clear, in this. |
| * n MUST be greater than, or equal to 0. |
| * @param setIt if true, then the n-th bit in this will be set, otherwise it |
| * will be cleared. |
| * |
| * output: |
| * @param r a copy of this NativeMPI's Pointer with its n-th bit set or cleared |
| * as requested. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natSetBit(JNIEnv *env, jobject this, |
| jint n, jboolean setIt, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_set (_r, _this); |
| if (setIt == JNI_TRUE) |
| { |
| mpz_setbit (_r, (unsigned long)n); |
| } |
| else |
| { |
| mpz_clrbit (_r, (unsigned long)n); |
| } |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) n; |
| (void) setIt; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |
| |
| /* |
| * @param this an instance of NativeMPI. |
| * |
| * output: |
| * @param r a NativeMPI's Pointer such that r = ~this. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_math_GMP_natNot(JNIEnv *env, jobject this, |
| jobject r) |
| { |
| #if defined(WITH_GNU_MP) |
| mpz_srcptr _this; |
| mpz_ptr _r; |
| |
| TRACE("begin"); |
| _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr)); |
| _r = (mpz_ptr)JCL_GetRawData (env, r); |
| mpz_com (_r, _this); |
| TRACE("end"); |
| #else /* !defined(WITH_GNU_MP) */ |
| (void) this; |
| (void) r; |
| throw_config_exception(env); |
| #endif /* defined(WITH_GNU_MP) */ |
| } |