/* not canonicalized */
void _lsrt_mpq_set_decimal(mpq_t q, const char *ptr, int radix)
{
mpz_t num, dec, exp;
mpq_t addend;
int ex, expdigits;
int s, e;
char ch = '+';
if (radix != 10)
lsrt_error("unsupported radix for exact decimal number: %d", radix);
mpz_init_set_ui(num, 0);
mpz_init_set_ui(dec, 0);
mpz_init(exp);
mpq_init(addend);
e = 0;
sscanf(ptr, "%[+-]%n", &ch, &e);
ptr += e;
e = 0;
gmp_sscanf(ptr, "%Zd%n", num, &e);
ptr += e;
s = 0;
e = 0;
expdigits = 0;
gmp_sscanf(ptr, ".%n%Zd%n", &s, dec, &e);
ptr += e;
if (e >= s)
expdigits = e - s;
s = 0;
e = 0;
ex = 0;
sscanf(ptr, "@%n%d%n", &s, &ex, &e);
if (e - s >= 5 || ex >= 256)
lsrt_error("decimal number out of range");
mpz_set(mpq_numref(q), dec);
mpz_ui_pow_ui(mpq_denref(q), radix, expdigits);
mpq_set_z(addend, num);
mpq_add(q, q, addend);
if (ex > 0) {
mpz_ui_pow_ui(exp, 10, ex); /* exponent is always in radix 10 */
mpz_mul(mpq_numref(q), mpq_numref(q), exp);
} else if (ex < 0) {
mpz_ui_pow_ui(exp, 10, -ex);
mpz_mul(mpq_denref(q), mpq_denref(q), exp);
}
if (ch == '-')
mpz_neg(mpq_numref(q), mpq_numref(q));
mpq_clear(addend);
mpz_clear(exp);
mpz_clear(num);
mpz_clear(dec);
}
/*
* Create a new pmpq structure from the content of a mpq
*/
pmpq *
pmpq_from_mpq(mpq_srcptr q)
{
pmpq *res;
int nsize = SIZ(mpq_numref(q));
if (LIKELY(0 != nsize))
{
int nalloc = ABS(nsize);
int dsize = SIZ(mpq_denref(q));
res = (pmpq *)palloc(
PMPQ_HDRSIZE + (nalloc + dsize) * sizeof(mp_limb_t));
res->num_size = nsize;
res->den_size = dsize;
SET_VARSIZE(res,
PMPQ_HDRSIZE + (nalloc + dsize) * sizeof(mp_limb_t));
memcpy(&(res->data), LIMBS(mpq_numref(q)),
nalloc * sizeof(mp_limb_t));
memcpy(&(res->data) + nalloc, LIMBS(mpq_denref(q)),
dsize * sizeof(mp_limb_t));
}
else
{
res = (pmpq *)palloc0(PMPQ_HDRSIZE);
SET_VARSIZE(res, PMPQ_HDRSIZE);
}
return res;
}
static void
e_mpq_num (mpq_ptr w, mpq_srcptr x)
{
if (w != x)
mpz_set (mpq_numref(w), mpq_numref(x));
mpz_set_ui (mpq_denref(w), 1L);
}
void
ensureWritableNumber(Number n)
{ switch(n->type)
{ case V_MPZ:
if ( !n->value.mpz->_mp_alloc )
{ mpz_t tmp;
tmp[0] = n->value.mpz[0];
mpz_init_set(n->value.mpz, tmp);
break;
}
case V_MPQ:
{ if ( !mpq_numref(n->value.mpq)->_mp_alloc )
{ mpz_t tmp;
tmp[0] = mpq_numref(n->value.mpq)[0];
mpz_init_set(mpq_numref(n->value.mpq), tmp);
}
if ( !mpq_denref(n->value.mpq)->_mp_alloc )
{ mpz_t tmp;
tmp[0] = mpq_denref(n->value.mpq)[0];
mpz_init_set(mpq_denref(n->value.mpq), tmp);
}
break;
}
default:
break;
}
}
void
check_various (void)
{
mpq_t x, y;
mpq_init (x);
mpq_init (y);
mpz_realloc (mpq_numref(x), (mp_size_t) 20);
mpz_realloc (mpq_denref(x), (mp_size_t) 20);
mpz_realloc (mpq_numref(y), (mp_size_t) 20);
mpz_realloc (mpq_denref(y), (mp_size_t) 20);
/* 0 == 0 */
SET4 (x, 0,13,12,11,10, 1,23,22,21,1);
SET4 (y, 0,33,32,31,30, 1,43,42,41,1);
check_all (x, y, 1);
/* 83/99 == 83/99 */
SET4 (x, 1,13,12,11,83, 1,23,22,21,99);
SET4 (y, 1,33,32,31,83, 1,43,42,41,99);
check_all (x, y, 1);
/* 1:2:3:4/5:6:7 == 1:2:3:4/5:6:7 */
SET4 (x, 4,1,2,3,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 1);
/* various individual changes making != */
SET4 (x, 4,1,2,3,667, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,1,2,666,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,1,666,3,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,667,2,3,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,1,2,3,4, 3,88,5,6,667);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,1,2,3,4, 3,88,5,667,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 4,1,2,3,4, 3,88,666,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, -4,1,2,3,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
SET4 (x, 1,1,2,3,4, 3,88,5,6,7);
SET4 (y, 4,1,2,3,4, 3,99,5,6,7);
check_all (x, y, 0);
mpq_clear (x);
mpq_clear (y);
}
obj rational_to_string_obj( obj a, unsigned radix )
{
mpq_t v;
size_t sz;
obj str, str2;
int len;
OBJ_TO_MPQ(v, a);
sz = mpz_sizeinbase(mpq_numref(v), radix) + 2;
if(mpz_sgn(mpq_numref(v))<0)
sz++;
sz += mpz_sizeinbase(mpq_denref(v), radix);
str = bvec_alloc(sz, string_class);
if(!mpz_get_str(PTR_TO_DATAPTR(str), radix, mpq_numref(v)))
return FALSE_OBJ;
len = strlen(PTR_TO_DATAPTR(str));
((char *)PTR_TO_DATAPTR(str))[len++]='/';
if(!mpz_get_str(PTR_TO_DATAPTR(str) + len, radix, mpq_denref(v)))
return FALSE_OBJ;
if(strlen(PTR_TO_DATAPTR(str)) == sz - 1)
return str;
str2 = bvec_alloc(sz - 1, string_class);
strcpy(PTR_TO_DATAPTR(str2), PTR_TO_DATAPTR(str));
return str2;
}
static PyObject *
GMPy_Rational_Abs(PyObject *x, CTXT_Object *context)
{
MPQ_Object *result = NULL;
if (MPQ_Check(x)) {
if (mpz_sgn(mpq_numref(MPQ(x))) >= 0) {
Py_INCREF(x);
return x;
}
else {
if ((result = GMPy_MPQ_New(context))) {
mpq_set(result->q, MPQ(x));
mpz_abs(mpq_numref(result->q), mpq_numref(result->q));
}
return (PyObject*)result;
}
}
/* This is safe because result is not an incremented reference to an
* existing value. MPQ is already handled so GMPy_MPQ_From_Rational()
* can't return an incremented reference to an existing value (which it
* would do if passed an MPQ).
*/
if ((result = GMPy_MPQ_From_Rational(x, context))) {
mpz_abs(mpq_numref(result->q), mpq_numref(result->q));
}
return (PyObject*)result;
}
void
check_rand (void)
{
mpq_t x, y, want_add, want_sub;
int i;
gmp_randstate_ptr rands = RANDS;
mpq_init (x);
mpq_init (y);
mpq_init (want_add);
mpq_init (want_sub);
for (i = 0; i < 500; i++)
{
mpz_errandomb (mpq_numref(x), rands, 512L);
mpz_errandomb_nonzero (mpq_denref(x), rands, 512L);
mpq_canonicalize (x);
mpz_errandomb (mpq_numref(y), rands, 512L);
mpz_errandomb_nonzero (mpq_denref(y), rands, 512L);
mpq_canonicalize (y);
refmpq_add (want_add, x, y);
refmpq_sub (want_sub, x, y);
check_all (x, y, want_add, want_sub);
}
mpq_clear (x);
mpq_clear (y);
mpq_clear (want_add);
mpq_clear (want_sub);
}
static PyObject *
GMPy_Rational_FloorDiv(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPZ_Object *result;
MPQ_Object *tempq;
CHECK_CONTEXT(context);
result = GMPy_MPZ_New(context);
tempq = GMPy_MPQ_New(context);
if (!result || !tempq) {
Py_XDECREF((PyObject*)result);
Py_XDECREF((PyObject*)tempq);
return NULL;
}
if (MPQ_Check(x) && MPQ_Check(y)) {
if (mpq_sgn(MPQ(y)) == 0) {
ZERO_ERROR("division or modulo by zero");
goto error;
}
mpq_div(tempq->q, MPQ(x), MPQ(y));
mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q));
Py_DECREF((PyObject*)tempq);
return (PyObject*)result;
}
if (IS_RATIONAL(x) && IS_RATIONAL(y)) {
MPQ_Object *tempx, *tempy;
tempx = GMPy_MPQ_From_Number(x, context);
tempy = GMPy_MPQ_From_Number(y, context);
if (!tempx || !tempy) {
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
goto error;
}
if (mpq_sgn(tempy->q) == 0) {
ZERO_ERROR("division or modulo by zero");
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
goto error;
}
mpq_div(tempq->q, tempx->q, tempy->q);
mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q));
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
Py_DECREF((PyObject*)tempq);
return (PyObject*)result;
}
Py_DECREF((PyObject*)result);
Py_RETURN_NOTIMPLEMENTED;
error:
Py_DECREF((PyObject*)result);
Py_DECREF((PyObject*)tempq);
return NULL;
}
int pp_solution(int index) {
pp_pp *pp, *cur;
int* v;
int i, r;
cur = pplist[index];
if (mpz_cmp_ui(mpq_numref(cur->spare), 1) > 0)
return 0;
r = mpz_get_ui(mpq_numref(cur->spare));
if (r == 1 && mpz_cmp_ui(mpq_denref(cur->spare), k0) > 0)
return 0;
r = (r == 0) ? 0 : mpz_get_ui(mpq_denref(cur->spare));
/* probable solution: spare == 0 or spare == 1/r, 1 <= r <= k0 */
gmp_printf("probable solution, spare = %Qd\n", cur->spare);
v = calloc((k0 + 32) >> 5, sizeof(int));
for (i = 0; i < pplistsize; ++i) {
pp = pplist[i];
if (pp->wrh) {
pp_setvec(v, pp, wr_vec(pp->wh, pp->wrh));
} else {
pp_setvec(v, pp, (int*)NULL);
}
}
if (pp_testbit(v, r)) {
/* exact solution */
v[r >> 5] &= ~(1 << (r & 31));
} else {
void
refmpq_sub (mpq_ptr w, mpq_srcptr x, mpq_srcptr y)
{
mpz_mul (mpq_numref(w), mpq_numref(x), mpq_denref(y));
mpz_submul (mpq_numref(w), mpq_denref(x), mpq_numref(y));
mpz_mul (mpq_denref(w), mpq_denref(x), mpq_denref(y));
mpq_canonicalize (w);
}
void rat_gmp_shift(const mpq_t z1, mpq_t z, int n)
{
if (n > 0)
mpz_mul_2exp(mpq_numref(z), mpq_numref(z1), n);
else if (n < 0)
mpz_mul_2exp(mpq_denref(z), mpq_denref(z1), (unsigned)-n);
mpq_canonicalize(z);
}
static Py_hash_t
Pympq_hash(PympqObject *self)
{
#ifdef _PyHASH_MODULUS
Py_hash_t hash = 0;
mpz_t temp, temp1, mask;
if (self->hash_cache != -1)
return self->hash_cache;
mpz_inoc(temp);
mpz_inoc(temp1);
mpz_inoc(mask);
mpz_set_si(mask, 1);
mpz_mul_2exp(mask, mask, _PyHASH_BITS);
mpz_sub_ui(mask, mask, 1);
if (!mpz_invert(temp, mpq_denref(self->q), mask)) {
mpz_cloc(temp);
mpz_cloc(temp1);
mpz_cloc(mask);
hash = _PyHASH_INF;
if (mpz_sgn(mpq_numref(self->q))<0)
hash = -hash;
self->hash_cache = hash;
return hash;
}
mpz_set(temp1, mask);
mpz_sub_ui(temp1, temp1, 2);
mpz_powm(temp, mpq_denref(self->q), temp1, mask);
mpz_tdiv_r(temp1, mpq_numref(self->q), mask);
mpz_mul(temp, temp, temp1);
hash = (Py_hash_t)mpn_mod_1(temp->_mp_d, mpz_size(temp), _PyHASH_MODULUS);
if (mpz_sgn(mpq_numref(self->q))<0)
hash = -hash;
if (hash==-1) hash = -2;
mpz_cloc(temp);
mpz_cloc(temp1);
mpz_cloc(mask);
self->hash_cache = hash;
return hash;
#else
PyObject *temp;
if (self->hash_cache != -1)
return self->hash_cache;
if (!(temp = Pympq_To_PyFloat(self))) {
SYSTEM_ERROR("Could not convert 'mpq' to float.");
return -1;
}
self->hash_cache = PyObject_Hash(temp);
Py_DECREF(temp);
return self->hash_cache;
#endif
}
static void
e_mpq_den (mpq_ptr w, mpq_srcptr x)
{
if (w == x)
mpz_swap (mpq_numref(w), mpq_denref(w));
else
mpz_set (mpq_numref(w), mpq_denref(x));
mpz_set_ui (mpq_denref(w), 1L);
}
void mpq::ceil() {
if (is_integer())
return;
bool pos = is_pos();
mpz_tdiv_q(mpq_numref(m_val), mpq_numref(m_val), mpq_denref(m_val));
mpz_set_ui(mpq_denref(m_val), 1);
if (pos)
mpz_add_ui(mpq_numref(m_val), mpq_numref(m_val), 1);
}
int cmp(mpq const & a, mpz const & b) {
if (a.is_integer()) {
return mpz_cmp(mpq_numref(a.m_val), mpq::zval(b));
} else {
static LEAN_THREAD_LOCAL mpz tmp;
mpz_mul(mpq::zval(tmp), mpq_denref(a.m_val), mpq::zval(b));
return mpz_cmp(mpq_numref(a.m_val), mpq::zval(tmp));
}
}
void mpq::floor() {
if (is_integer())
return;
bool neg = is_neg();
mpz_tdiv_q(mpq_numref(m_val), mpq_numref(m_val), mpq_denref(m_val));
mpz_set_ui(mpq_denref(m_val), 1);
if (neg)
mpz_sub_ui(mpq_numref(m_val), mpq_numref(m_val), 1);
}
double AB_Value_GetValueAsDouble(const AB_VALUE *v) {
assert(v);
if (mpz_fits_slong_p(mpq_numref(v->value)) && mpz_fits_slong_p(mpq_denref(v->value))) {
return (double) (mpz_get_d(mpq_numref(v->value)) / mpz_get_d(mpq_denref(v->value)));
}
else {
return mpq_get_d(v->value);
}
}
void
toTrueNumber(mpq_t a, const mpz_t halfPrime, const mpz_t prime)
{
if (mpz_cmp(halfPrime, mpq_numref(a)) < 0)
{
mpz_sub(mpq_numref(a), mpq_numref(a), prime);
mpq_canonicalize(a);
}
}
static obj rational_compact( mpq_t a )
{
mpq_canonicalize( a );
if(abs( mpq_denref( a )->_mp_size ) == 1 &&
mpz_get_ui( mpq_denref( a ) ) == 1)
return bignum_compact( mpq_numref( a ) );
return make2( mp_rational_class,
mpz_to_bignum( mpq_numref( a ) ),
mpz_to_bignum( mpq_denref( a ) ) );
}
std::ostream & operator<<(std::ostream & out, mpq const & v) {
if (v.is_integer()) {
display(out, mpq_numref(v.m_val));
} else {
display(out, mpq_numref(v.m_val));
out << "/";
display(out, mpq_denref(v.m_val));
}
return out;
}
void random(ElementType& result) const {
rawSetRandomQQ(&result, 0);
#if 0
mpz_urandomb(mpq_numref(&result), mRandomState, mMaxHeight);
mpz_urandomb(mpq_denref(&result), mRandomState, mMaxHeight);
mpz_add_ui(mpq_numref(&result), mpq_numref(&result), 1);
mpz_add_ui(mpq_denref(&result), mpq_denref(&result), 1);
mpq_canonicalize(&result);
#endif
}
static PyObject *
Pympq_abs(PympqObject *self)
{
PympqObject *result;
if ((result = (PympqObject*)Pympq_new())) {
mpq_set(result->q, self->q);
mpz_abs(mpq_numref(result->q), mpq_numref(result->q));
}
return (PyObject*)result;
}
void convert_to_z(mpz_t z, const mpq_t q, const mpz_t prime) {
assert(mpz_sgn(prime) != 0);
if (mpz_cmp_ui(mpq_denref(q), 1) == 0) {
mpz_set(z, mpq_numref(q));
if (mpq_sgn(q) < 0) {
mpz_mod(z, z, prime);
}
} else if (mpz_cmp_ui(mpq_denref(q), 0) == 0) {
mpz_set_ui(z, 0);
} else {
mpz_invert(z, mpq_denref(q), prime);
mpz_mul(z, z, mpq_numref(q));
mpz_mod(z, z, prime);
}
}
//Refer to apps_sfdl_gen/ram_hybrid_micro_cons.h for constants to use when generating input.
void ram_hybrid_microVerifierInpGenHw::create_input(mpq_t* input_q, int num_inputs)
{
#if IS_REDUCER == 0
//Default implementation is provided by compiler
compiler_implementation.create_input(input_q, num_inputs);
#endif
// setup the Merkle root when the hybrid choose Merkle-tree based
// solution
if (num_inputs > 1) {
ConfigurableBlockStore bs;
RAMImpl ram(&bs);
HashType* hash = ram.getRootHash();
int i = 0;
for (HashType::HashVec::const_iterator itr = hash->GetFieldElts().begin();
itr != hash->GetFieldElts().end(); ++itr) {
mpz_set(mpq_numref(input_q[i]), (*itr).get_mpz_t());
mpq_canonicalize(input_q[i]);
i++;
}
}
// set the address for RAM operation to be 0
mpq_set_ui(input_q[num_inputs-1], 0, 1);
// states that should be persisted and may not be generated everytime should be created here.
if (generate_states) {
}
}
void
mpq_set_ui (MP_RAT *dest, unsigned long int num, unsigned long int den)
{
if (GMP_NUMB_BITS < BITS_PER_ULONG)
{
if (num == 0) /* Canonicalize 0/d to 0/1. */
den = 1;
mpz_set_ui (mpq_numref (dest), num);
mpz_set_ui (mpq_denref (dest), den);
return;
}
if (num == 0)
{
/* Canonicalize 0/n to 0/1. */
den = 1;
SIZ(NUM(dest)) = 0;
}
else
{
PTR(NUM(dest))[0] = num;
SIZ(NUM(dest)) = 1;
}
PTR(DEN(dest))[0] = den;
SIZ(DEN(dest)) = (den != 0);
}
void
mpq_set_si (MP_RAT *dest, signed long int num, unsigned long int den)
{
unsigned long int abs_num;
if (GMP_NUMB_BITS < BITS_PER_ULONG)
{
if (num == 0) /* Canonicalize 0/d to 0/1. */
den = 1;
mpz_set_si (mpq_numref (dest), num);
mpz_set_ui (mpq_denref (dest), den);
return;
}
abs_num = ABS_CAST (unsigned long, num);
if (num == 0)
{
/* Canonicalize 0/d to 0/1. */
den = 1;
dest->_mp_num._mp_size = 0;
}
else
{
dest->_mp_num._mp_d[0] = abs_num;
dest->_mp_num._mp_size = num > 0 ? 1 : -1;
}
dest->_mp_den._mp_d[0] = den;
dest->_mp_den._mp_size = (den != 0);
}
/// @Mike: change all uses of set_from_mpq to return bool
// or, perhaps, to raise an exception.
void ARingZZpFFPACK::set_from_mpq(ElementType &result, const mpq_ptr a) const
{
ElementType n, d;
set_from_mpz(n, mpq_numref(a));
set_from_mpz(d, mpq_denref(a));
divide(result, n, d);
}
void
check_data (void)
{
static const struct {
int base;
const char *num;
const char *den;
const char *want;
} data[] = {
{ 10, "0", "1", "0" },
{ 10, "1", "1", "1" },
{ 16, "ffffffff", "1", "ffffffff" },
{ 16, "ffffffffffffffff", "1", "ffffffffffffffff" },
{ 16, "1", "ffffffff", "1/ffffffff" },
{ 16, "1", "ffffffffffffffff", "1/ffffffffffffffff" },
{ 16, "1", "10000000000000003", "1/10000000000000003" },
{ 10, "12345678901234567890", "9876543210987654323",
"12345678901234567890/9876543210987654323" },
};
mpq_t q;
int i;
mpq_init (q);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (mpq_numref(q), data[i].num, data[i].base);
mpz_set_str_or_abort (mpq_denref(q), data[i].den, data[i].base);
check_all (q, data[i].base, data[i].want);
}
mpq_clear (q);
}
void
mpq_set_si (mpq_ptr dest, mpir_si num, mpir_ui den)
{
mpir_ui abs_num;
if (GMP_NUMB_BITS < BITS_PER_UI)
{
if (num == 0) /* Canonicalize 0/d to 0/1. */
den = 1;
mpz_set_si (mpq_numref (dest), num);
mpz_set_ui (mpq_denref (dest), den);
return;
}
abs_num = ABS (num);
if (num == 0)
{
/* Canonicalize 0/d to 0/1. */
den = 1;
dest->_mp_num._mp_size = 0;
}
else
{
dest->_mp_num._mp_d[0] = abs_num;
dest->_mp_num._mp_size = num > 0 ? 1 : -1;
}
dest->_mp_den._mp_d[0] = den;
dest->_mp_den._mp_size = (den != 0);
}
