mirror of git://gcc.gnu.org/git/gcc.git
1397 lines
40 KiB
C
1397 lines
40 KiB
C
/* 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) */
|
|
}
|