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); } }
Term Yap_MkBigIntTerm(MP_INT *big) { CACHE_REGS Int nlimbs; MP_INT *dst = (MP_INT *)(H+2); CELL *ret = H; Int bytes; if (mpz_fits_slong_p(big)) { long int out = mpz_get_si(big); return MkIntegerTerm((Int)out); } // bytes = big->_mp_alloc * sizeof(mp_limb_t); // nlimbs = ALIGN_YAPTYPE(bytes,CELL)/CellSize; // this works, but it shouldn't need to do this... nlimbs = big->_mp_alloc; bytes = nlimbs*sizeof(CELL); if (nlimbs > (ASP-ret)-1024) { return TermNil; } H[0] = (CELL)FunctorBigInt; H[1] = BIG_INT; dst->_mp_size = big->_mp_size; dst->_mp_alloc = nlimbs*(CellSize/sizeof(mp_limb_t)); memmove((void *)(dst+1), (const void *)(big->_mp_d), bytes); H = (CELL *)(dst+1)+nlimbs; H[0] = EndSpecials; H++; return AbsAppl(ret); }
int qsieve_getsize(mpz_t x) { int t; t = mpz_get_si(x); if(mpz_fits_slong_p(x)) return t; return (t<0 ? -0x7FFFFFFF : +0x7FFFFFFF); }
ecl_long_long_t ecl_to_long_long(cl_object x) { if (ECL_FIXNUMP(x)) { return (ecl_long_long_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_slong_p(x->big.big_num)) { return (ecl_long_long_t)mpz_get_si(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); int i = ECL_LONG_LONG_BITS - FIXNUM_BITS; mpz_fdiv_q_2exp(copy->bit.big_num, x->big.big_num, i); if (mpz_fits_ulong_p(copy->big.big_num)) { volatile ecl_long_long_t output; output = mpz_get_si(copy->big.big_num); for (i -= FIXNUM_BITS; i; i-= FIXNUM_BITS) { output = (output << FIXNUM_BITS); output += mpz_get_ui(x->big.big_num); } return output; } } FEwrong_type_argument(cl_list(3,ECL_SYM("INTEGER",437), ecl_negate(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1)), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1))), x); }
/* This function is used by Miller */ int step3(int j, mpz_t m, mpz_t x, mpz_t a, mpz_t p, mpz_t p1){ int newm; int somethi = (int) pow(2.0,(double)j); printf("something = %d\n", somethi); if(mpz_fits_slong_p(m) == 0){ printf("this is problematic cause m is too huge for gmp to handle"); return 0; } else{ newm = mpz_get_si(m); } somethi = somethi*newm; printf("something (after new M) = %d\n", somethi); gmp_printf("x (before mod): %Zd\t & p1: %Zd\n", x, p1); mpz_powm_ui(x, a, somethi, p); gmp_printf("x (step 3) = %Zd\n", x); if(mpz_cmp_ui(x, 1) == 0){ printf("entered if\n"); return 0; } else if(mpz_cmp(x, p1) == 0){ printf("enter else if\n"); return 1; } else{ printf("enter else, let's see j's value, %d\n", j); return ++j; } }
std::pair<bool, int> RingZZ::get_si(mpz_t n) { if (not mpz_fits_slong_p(n)) return std::make_pair<bool, int>(false, 0); long a = mpz_get_si(n); int b = static_cast<int>(a); if (a == b) return std::make_pair<bool, int>(true, std::move(b)); return std::make_pair<bool, int>(false, 0); }
/* mpz -> pyint/pylong conversion; if the value fits in a python int, it returns a python int (optimised for that pathway), otherwise returns a python long */ PyObject * mpz_get_pyintlong(mpz_srcptr z) { if (mpz_fits_slong_p(z)) return PyInt_FromLong(mpz_get_si(z)); return mpz_get_pylong(z); }
object make_integer(__mpz_struct *u) { if ((u)->_mp_size == 0) return small_fixnum(0); if (mpz_fits_slong_p(u)) { return make_fixnum(mpz_get_si(u)); } return make_bignum(u); }
/* void camlidl_mpq_ml2c(value val, __mpq_struct* mpq) { *mpq = *((mpq_ptr)(Data_custom_val(val))); } */ int mpz_fits_int_p (mpz_t OP) { if (mpz_fits_slong_p(OP)) { long v = mpz_get_si(OP); return (Min_long <= v && v<=Max_long); } else { return 0; } }
static CBIGINT *_pow(CBIGINT *a, CBIGINT *b, bool invert) { if (!mpz_fits_slong_p(b->n)) { GB.Error(GB_ERR_OVERFLOW); return NULL; } return BIGINT_make_int(a, mpz_get_si(b->n), mpz_pow_ui); }
int fmpz_fits_si(const fmpz_t f) { if (!COEFF_IS_MPZ(*f)) { return 1; } else { return mpz_fits_slong_p(COEFF_TO_PTR(*f)); } }
cl_fixnum fixint(cl_object x) { if (ECL_FIXNUMP(x)) return ecl_fixnum(x); if (ECL_BIGNUMP(x)) { if (mpz_fits_slong_p(x->big.big_num)) { return mpz_get_si(x->big.big_num); } } FEwrong_type_argument(ecl_make_fixnum(/*FIXNUM*/372), x); }
void power_mpz(ElementType &result, const ElementType& a, mpz_ptr n) const { if (mpz_fits_slong_p(n)) { int n1 = static_cast<int>(mpz_get_si(n)); power(result,a,n1); } else { ERROR("exponent too large"); set_from_long(result, 1); } }
extern "C" Py_ssize_t PyLong_AsSsize_t(PyObject* vv) noexcept { RELEASE_ASSERT(PyLong_Check(vv), ""); if (PyLong_Check(vv)) { BoxedLong* l = static_cast<BoxedLong*>(vv); if (mpz_fits_slong_p(l->n)) { return mpz_get_si(l->n); } else { PyErr_SetString(PyExc_OverflowError, "long int too large to convert to int"); return -1; } } Py_FatalError("unimplemented"); }
ecl_int64_t ecl_to_int64_t(cl_object x) { if (ECL_FIXNUMP(x)) { return (ecl_int64_t)ecl_fixnum(x); } else if (!ECL_BIGNUMP(x)) { (void)0; } else if (mpz_fits_slong_p(x->big.big_num)) { return (ecl_int64_t)mpz_get_si(x->big.big_num); } else { cl_object copy = _ecl_big_register0(); mpz_fdiv_q_2exp(copy->big.big_num, x->big.big_num, 32); if (mpz_fits_slong_p(copy->big.big_num)) { ecl_int64_t output; output = (ecl_int64_t)mpz_get_si(copy->big.big_num); mpz_fdiv_r_2exp(copy->big.big_num, x->big.big_num, 32); return (output << 32) + mpz_get_ui(copy->big.big_num); } } FEwrong_type_argument(cl_list(3,ECL_SYM("INTEGER",437), ecl_negate(ecl_ash(ecl_make_fixnum(1), 63)), ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 63))), x); }
int fmpz_fits_si(const fmpz_t f) { if (!COEFF_IS_MPZ(*f)) { return 1; } else { #if defined(_WIN64) return flint_mpz_fits_si_p(COEFF_TO_PTR(*f)); #else return mpz_fits_slong_p(COEFF_TO_PTR(*f)); #endif } }
/* Converts a GMP integer into a backend tree node. */ tree gfc_conv_mpz_to_tree (mpz_t i, int kind) { HOST_WIDE_INT high; unsigned HOST_WIDE_INT low; if (mpz_fits_slong_p (i)) { /* Note that HOST_WIDE_INT is never smaller than long. */ low = mpz_get_si (i); high = mpz_sgn (i) < 0 ? -1 : 0; } else { unsigned HOST_WIDE_INT words[2]; size_t count; /* Since we know that the value is not zero (mpz_fits_slong_p), we know that at one word will be written, but we don't know about the second. It's quicker to zero the second word before that conditionally clear it later. */ words[1] = 0; /* Extract the absolute value into words. */ mpz_export (words, &count, -1, sizeof (HOST_WIDE_INT), 0, 0, i); /* We assume that all numbers are in range for its type, and that we never create a type larger than 2*HWI, which is the largest that the middle-end can handle. */ gcc_assert (count == 1 || count == 2); low = words[0]; high = words[1]; /* Negate if necessary. */ if (mpz_sgn (i) < 0) { if (low == 0) high = -high; else low = -low, high = ~high; } } return build_int_cst_wide (gfc_get_int_type (kind), low, high); }
static CRATIONAL *_powo(CRATIONAL *a, void *o, bool invert) { CBIGINT *b; if (invert || !GB.Is(o, CLASS_BigInt)) return NULL; b = (CBIGINT *)o; if (!mpz_fits_slong_p(b->n)) { GB.Error(GB_ERR_OVERFLOW); return NULL; } return _powf(a, (double)mpz_get_si(b->n), invert); }
static CBIGINT *_powf(CBIGINT *a, double f, bool invert) { if (invert) { mpz_t b; if (!mpz_fits_slong_p(a->n)) return NULL; mpz_init_set_si(b, (long)f); mpz_pow_ui(b, b, mpz_get_si(a->n)); return BIGINT_create(b); } else return BIGINT_make_int(a, f, mpz_pow_ui); }
int check_si (mpz_t sz, mpz_t oz, long si, long oi, int c) { mpz_t t; int fail; if (mpz_cmp_si (sz, oi) != c) { printf ("mpz_cmp_si (sz, %ld) != %i.\n", oi, c); printf (" sz="); mpz_out_str (stdout, 10, sz); printf ("\n"); abort (); } if ((si < oi ? -1 : si > oi) != c) return 1; mpz_init_set_si (t, si); if ((fail = mpz_cmp_si (sz, si)) != 0) printf ("mpz_cmp_si (sz, %ld) != 0.\n", si); if (mpz_cmp_si (oz, si) != -c) printf ("mpz_cmp_si (oz, %ld) != %i.\n", si, -c), fail = 1; if (! mpz_fits_slong_p (sz)) printf ("mpz_fits_slong_p (sz) != 1.\n"), fail = 1; if (mpz_get_si (sz) != si) printf ("mpz_get_si (sz) != %ld.\n", si), fail = 1; if (mpz_cmp (t, sz) != 0) { printf ("mpz_init_set_si (%ld) failed.\n", si); printf (" got="); mpz_out_str (stdout, 10, t); printf ("\n"); fail = 1; } mpz_clear (t); if (fail) { printf (" sz="); mpz_out_str (stdout, 10, sz); printf ("\n"); printf (" oz="); mpz_out_str (stdout, 10, oz); printf ("\n"); printf (" si=%ld\n", si); abort (); } return 0; }
signed long vanilla::int_object_to_signed_long(object::ptr const& obj) { if(obj->type_id() != OBJECT_ID_INT) { BOOST_THROW_EXCEPTION(error::bad_cast_error() << error::first_operand(obj) << error::cast_target_name("int")); } mpz_t& mpz = static_cast<int_object const*>(obj.get())->value().mpz(); if(!mpz_fits_slong_p(mpz)) { BOOST_THROW_EXCEPTION(error::integer_conversion_overflow_error() << error::first_operand(obj) << error::integer_conversion_target_type("signed long")); } return mpz_get_si(mpz); }
extern "C" long PyLong_AsLongAndOverflow(Box* vv, int* overflow) noexcept { // Ported from CPython; original comment: /* This version by Tim Peters */ *overflow = 0; if (vv == NULL) { PyErr_BadInternalCall(); return -1; } if (PyInt_Check(vv)) return PyInt_AsLong(vv); if (!PyLong_Check(vv)) { PyNumberMethods* nb; nb = vv->cls->tp_as_number; if (nb == NULL || nb->nb_int == NULL) { PyErr_SetString(PyExc_TypeError, "an integer is required"); return -1; } vv = (*nb->nb_int)(vv); if (vv == NULL) return -1; if (PyInt_Check(vv)) return PyInt_AsLong(vv); if (!PyLong_Check(vv)) { PyErr_SetString(PyExc_TypeError, "nb_int should return int object"); return -1; } // fallthrough: this has to be a long } BoxedLong* l = static_cast<BoxedLong*>(vv); if (mpz_fits_slong_p(l->n)) { return mpz_get_si(l->n); } else { *overflow = mpz_sgn(l->n); return -1; } }
Value Bignum::add(long n) const { mpz_t result; mpz_init_set(result, _z); if (n >= 0) mpz_add_ui(result, result, (unsigned long) n); else mpz_sub_ui(result, result, (unsigned long) -n); if (mpz_fits_slong_p(result)) { long n = mpz_get_si(result); if (n >= MOST_NEGATIVE_FIXNUM && n <= MOST_POSITIVE_FIXNUM) { MPZ_CLEAR(result); return make_fixnum(n); } } return make_value(new Bignum(result, false)); }
APLRAT PrimFnMonQuoteDotRisR (APLRAT aplRatRht, LPPRIMSPEC lpPrimSpec) { APLRAT mpqRes = {0}; UINT uRht; // Check for indeterminates: !N for integer N < 0 if (mpq_integer_p (&aplRatRht) && mpq_cmp_ui (&aplRatRht, 0, 1) < 0) return *mpq_QuadICValue (&aplRatRht, // No left arg ICNDX_QDOTn, &aplRatRht, &mpqRes, FALSE); // Check for PosInfinity if (IsMpqPosInfinity (&aplRatRht)) return mpqPosInfinity; // If the denominator is 1, // and the numerator fts in a UINT, ... if (mpq_integer_p (&aplRatRht) && mpz_fits_slong_p (mpq_numref (&aplRatRht)) NE 0) { // Initialize the result to 0/1 mpq_init (&mpqRes); // Extract the numerator uRht = (UINT) mpz_get_si (mpq_numref (&aplRatRht)); // Compute the factorial mpz_fac_ui (mpq_numref (&mpqRes), uRht); } else RaiseException (EXCEPTION_RESULT_VFP, 0, 0, NULL); return mpqRes; } // End PrimFnMonQuoteDotRisR
void try_op_si (int c) { long si, oi; mpz_t sz, oz; si = c; mpz_init_set_si (sz, si); oi = si; mpz_init_set (oz, sz); do { si *= 2; /* c * 2^k */ mpz_mul_2exp (sz, sz, 1); if (check_si (sz, oz, si, oi, c)) { mpz_set (oz, sz); break; } oi = si + c; /* c * (2^k + 1) */ if (c == -1) mpz_sub_ui (oz, sz, 1); else mpz_add_ui (oz, sz, 1); if (check_si (oz, sz, oi, si, c)) break; oi = (si - c) * 2 + c; /* c * (2^K - 1) */ mpz_mul_si (oz, sz, 2*c); if (c == -1) mpz_ui_sub (oz, 1, oz); /* oz = sz * 2 + 1 */ else mpz_sub_ui (oz, oz, 1); /* oz = sz * 2 - 1 */ } while (check_si (oz, sz, oi, si, c) == 0); mpz_clear (sz); if (mpz_fits_slong_p (oz)) { printf ("Should not fit a signed long any more.\n"); printf (" oz="); mpz_out_str (stdout, 10, oz); printf ("\n"); abort (); } if (mpz_cmp_si (oz, -c) != c) { printf ("mpz_cmp_si (oz, %i) != %i.\n", c, c); printf (" oz="); mpz_out_str (stdout, 10, oz); printf ("\n"); abort (); } mpz_mul_2exp (oz, oz, 1); if (mpz_cmp_si (oz, -c) != c) { printf ("mpz_cmp_si (oz, %i) != %i.\n", c, c); printf (" oz="); mpz_out_str (stdout, 10, oz); printf ("\n"); abort (); } mpz_clear (oz); }
int gmpint_fits_int(mpz_t *op) { return mpz_fits_slong_p(*op); }
int main(int argc, char *argv[]) { Vstr_base *s1 = ex_init(NULL); mpz_t bignum; const char *loc_num_name = NULL; Vstr_ref *ref = NULL; const unsigned int num_flags = (VSTR_FLAG_PARSE_NUM_SEP | VSTR_FLAG_PARSE_NUM_SPACE); if (argc < 2) errx(EXIT_FAILURE, "No count specified"); vstr_cntl_conf(s1->conf, VSTR_CNTL_CONF_SET_FMT_CHAR_ESC, '$'); vstr_fmt_add(s1->conf, "<dMPZ:%p>", ex_usr_dmpz_cb, VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END); vstr_fmt_add(s1->conf, "<oMPZ:%p>", ex_usr_ompz_cb, VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END); vstr_fmt_add(s1->conf, "<xMPZ:%p>", ex_usr_xmpz_cb, VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END); vstr_fmt_add(s1->conf, "<bMPZ:%p>", ex_usr_bmpz_cb, VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END); setlocale(LC_ALL, ""); loc_num_name = setlocale(LC_NUMERIC, NULL); if (!vstr_cntl_conf(s1->conf, VSTR_CNTL_CONF_SET_LOC_CSTR_AUTO_NAME_NUMERIC, loc_num_name)) errx(EXIT_FAILURE, "Couldn't change numeric locale info"); mpz_init(bignum); if (!vstr_add_cstr_ptr(s1, 0, argv[1]) || !vstr_parse_num(s1, 1, s1->len, num_flags, NULL, NULL, vmpz_num, bignum)) errno = ENOMEM, err(EXIT_FAILURE, "Couldn't init number"); vstr_del(s1, 1, s1->len); #if (EX_GMP_NUMS_USE_TST) { mpz_abs(bignum, bignum); mpz_neg(bignum, bignum); do { mpz_neg(bignum, bignum); vstr_add_fmt(s1, s1->len, "%%'20.40d = <$'20.40<dMPZ:%p>>\n", (void *)bignum); if (mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'20.40d = <%'20.40ld>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%'40.20d = <$'40.20<dMPZ:%p>>\n", (void *)bignum); if (mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'40.20d = <%'40.20ld>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%'20.40o = <$'20.40<oMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'20.40o = <%'20.40lo>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%'40.20o = <$'40.20<oMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'40.20o = <%'40.20lo>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%'20.40x = <$'20.40<xMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'20.40x = <%'20.40lx>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%'40.20x = <$'40.20<xMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%'40.20x = <%'40.20lx>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'40d = <$#'40<dMPZ:%p>>\n", (void *)bignum); if (mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'40d = <%#'40ld>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'-40d = <$#'-40<dMPZ:%p>>\n", (void *)bignum); if (mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'-40d = <%#'-40ld>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'40o = <$#'40<oMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'40o = <%#'40lo>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'-40o = <$#'-40<oMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'-40o = <%#'-40lo>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'40x = <$#'40<xMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'40x = <%#'40lx>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'-40x = <$#'-40<xMPZ:%p>>\n", (void *)bignum); if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum)) vstr_add_fmt(s1, s1->len, "%%#'-40x = <%#'-40lx>\n", mpz_get_si(bignum)); vstr_add_fmt(s1, s1->len, "%%#'b = <$#'<bMPZ:%p>>\n", (void *)bignum); vstr_add_rep_chr(s1, s1->len, '-', 79); vstr_add_rep_chr(s1, s1->len, '\n', 1); } while (mpz_sgn(bignum) > 0); mpz_abs(bignum, bignum); } #endif if (!(ref = vstr_ref_make_strdup("_"))) errno = ENOMEM, err(EXIT_FAILURE, "Ref seperator"); if (!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 2, ref, 1) || !vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 8, ref, 1) || !vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 16, ref, 1) || FALSE) errno = ENOMEM, err(EXIT_FAILURE, "Add seperator"); vstr_ref_del(ref); if (!(ref = vstr_ref_make_strdup("\4"))) errno = ENOMEM, err(EXIT_FAILURE, "Ref grouping"); if (!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_GRP, 2, ref) || !vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_GRP, 16, ref) || FALSE) errno = ENOMEM, err(EXIT_FAILURE, "Add grouping"); vstr_ref_del(ref); vstr_add_fmt(s1, s1->len, " Input: %s\n", argv[1]); vstr_add_fmt(s1, s1->len, " %%#'x = $#'<xMPZ:%p>\n", (void *)bignum); vstr_add_fmt(s1, s1->len, " %%#'d = $#'<dMPZ:%p>\n", (void *)bignum); vstr_add_fmt(s1, s1->len, " %%#'o = $#'<oMPZ:%p>\n", (void *)bignum); vstr_add_fmt(s1, s1->len, " %%#'b = $#'<bMPZ:%p>\n", (void *)bignum); if (s1->conf->malloc_bad) errno = ENOMEM, err(EXIT_FAILURE, "Add string data"); io_put_all(s1, STDOUT_FILENO); exit (ex_exit(s1, NULL)); }
void power_mpz(ElementType& result,const ElementType& a,const mpz_ptr n) const { if (mpz_fits_slong_p(n)) power(result, a, mpz_get_ui(n)); else throw exc::engine_error("attempted to take a power of an integer to too large of a power"); }
void check_data (void) { static const struct { int a_base; const char *a; const char *b; int want; } data[] = { { 10, "0", "1", -1 }, { 10, "0", "0", 0 }, { 10, "0", "-1", 1 }, { 10, "1", "1", 0 }, { 10, "1", "0", 1 }, { 10, "1", "-1", 1 }, { 10, "-1", "1", -1 }, { 10, "-1", "0", -1 }, { 10, "-1", "-1", 0 }, { 16, "0", "-0x80000000", 1 }, { 16, "80000000", "-0x80000000", 1 }, { 16, "80000001", "-0x80000000", 1 }, { 16, "-80000000", "-0x80000000", 0 }, { 16, "-80000001", "-0x80000000", -1 }, { 16, "-FF0080000001", "-0x80000000", -1 }, { 16, "0", "-0x8000000000000000", 1 }, { 16, "8000000000000000", "-0x8000000000000000", 1 }, { 16, "8000000000000001", "-0x8000000000000000", 1 }, { 16, "-8000000000000000", "-0x8000000000000000", 0 }, { 16, "-8000000000000001", "-0x8000000000000000", -1 }, { 16, "-FF008000000000000001", "-0x8000000000000000", -1 }, }; mpf_t a; mpz_t bz; long b; int got; int i; mpf_init (a); mpz_init (bz); for (i = 0; i < numberof (data); i++) { mpf_set_str_or_abort (a, data[i].a, data[i].a_base); mpz_set_str_or_abort (bz, data[i].b, 0); if (mpz_fits_slong_p (bz)) { b = mpz_get_si (bz); got = mpf_cmp_si (a, b); if (SGN (got) != data[i].want) { printf ("mpf_cmp_si wrong on data[%d]\n", i); printf (" a="); mpf_out_str (stdout, 10, 0, a); printf (" (%s)\n", data[i].a); printf (" b=%ld (%s)\n", b, data[i].b); printf (" got=%d\n", got); printf (" want=%d\n", data[i].want); abort(); } } } mpf_clear (a); mpz_clear (bz); }
bool RingZZ::get_si(int &result, mpz_t n) { result = static_cast<int>(mpz_get_si(n)); return mpz_fits_slong_p(n); }