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