void mpq_set (mpq_ptr dest, mpq_srcptr src) { mp_size_t num_size, den_size; mp_size_t abs_num_size; mp_ptr dp; num_size = SIZ(NUM(src)); SIZ(NUM(dest)) = num_size; abs_num_size = ABS (num_size); dp = MPZ_NEWALLOC (NUM(dest), abs_num_size); MPN_COPY (dp, PTR(NUM(src)), abs_num_size); den_size = SIZ(DEN(src)); SIZ(DEN(dest)) = den_size; dp = MPZ_NEWALLOC (DEN(dest), den_size); MPN_COPY (dp, PTR(DEN(src)), den_size); }
void mpq_abs (mpq_ptr dst, mpq_srcptr src) { mp_size_t num_abs_size = ABSIZ(NUM(src)); if (dst != src) { mp_size_t den_size = SIZ(DEN(src)); mp_ptr dp; dp = MPZ_NEWALLOC (NUM(dst), num_abs_size); MPN_COPY (dp, PTR(NUM(src)), num_abs_size); dp = MPZ_NEWALLOC (DEN(dst), den_size); SIZ(DEN(dst)) = den_size; MPN_COPY (dp, PTR(DEN(src)), den_size); } SIZ(NUM(dst)) = num_abs_size; }
void mpq_set_num (mpq_ptr dest, mpz_srcptr num) { mp_size_t size = SIZ (num); mp_size_t abs_size = ABS (size); mp_ptr dp; dp = MPZ_NEWALLOC (NUM(dest), abs_size); SIZ(NUM(dest)) = size; MPN_COPY (dp, PTR(num), abs_size); }
void mpq_set_den (mpq_ptr dest, mpz_srcptr den) { mp_size_t size = SIZ (den); mp_size_t abs_size = ABS (size); mp_ptr dp; dp = MPZ_NEWALLOC (DEN(dest), abs_size); SIZ(DEN(dest)) = size; MPN_COPY (dp, PTR(den), abs_size); }
void mpq_inv (mpq_ptr dest, mpq_srcptr src) { mp_size_t num_size = SIZ(NUM(src)); mp_size_t den_size = SIZ(DEN(src)); if (num_size < 0) { num_size = -num_size; den_size = -den_size; } else if (UNLIKELY (num_size == 0)) DIVIDE_BY_ZERO; SIZ(DEN(dest)) = num_size; SIZ(NUM(dest)) = den_size; /* If dest == src we may just swap the numerator and denominator; we ensured that the new denominator is positive. */ if (dest == src) { MP_PTR_SWAP (PTR(NUM(dest)), PTR(DEN(dest))); MP_SIZE_T_SWAP (ALLOC(NUM(dest)), ALLOC(DEN(dest))); } else { mp_ptr dp; den_size = ABS (den_size); dp = MPZ_NEWALLOC (NUM(dest), den_size); MPN_COPY (dp, PTR(DEN(src)), den_size); dp = MPZ_NEWALLOC (DEN(dest), num_size); MPN_COPY (dp, PTR(NUM(src)), num_size); } }
void mpz_rrandomb (mpz_ptr x, gmp_randstate_t rstate, mp_bitcnt_t nbits) { mp_size_t nl; mp_ptr xp; nl = BITS_TO_LIMBS (nbits); if (nbits != 0) { xp = MPZ_NEWALLOC (x, nl); gmp_rrandomb (xp, rstate, nbits); } SIZ(x) = nl; }
void mpz_set_ui (mpz_ptr dest, unsigned long int val) { mp_size_t size; MPZ_NEWALLOC (dest, 1)[0] = val & GMP_NUMB_MASK; size = val != 0; #if BITS_PER_ULONG > GMP_NUMB_BITS /* avoid warnings about shift amount */ if (val > GMP_NUMB_MAX) { MPZ_REALLOC (dest, 2); PTR (dest)[1] = val >> GMP_NUMB_BITS; size = 2; }
void mpz_fib2_ui (mpz_ptr fn, mpz_ptr fnsub1, unsigned long n) { mp_ptr fp, f1p; mp_size_t size; if (n <= FIB_TABLE_LIMIT) { MPZ_NEWALLOC (fn, 1)[0] = FIB_TABLE (n); SIZ(fn) = (n != 0); /* F[0]==0, others are !=0 */ MPZ_NEWALLOC (fnsub1, 1)[0] = FIB_TABLE ((int) n - 1); SIZ(fnsub1) = (n != 1); /* F[1-1]==0, others are !=0 */ return; } size = MPN_FIB2_SIZE (n); fp = MPZ_NEWALLOC (fn, size); f1p = MPZ_NEWALLOC (fnsub1, size); size = mpn_fib2_ui (fp, f1p, n); SIZ(fn) = size; SIZ(fnsub1) = size - (f1p[size-1] == 0); }
void mpq_set_z (mpq_ptr dest, mpz_srcptr src) { mp_size_t num_size; mp_size_t abs_num_size; mp_ptr dp; num_size = SIZ (src); abs_num_size = ABS (num_size); dp = MPZ_NEWALLOC (NUM(dest), abs_num_size); SIZ(NUM(dest)) = num_size; MPN_COPY (dp, PTR(src), abs_num_size); PTR(DEN(dest))[0] = 1; SIZ(DEN(dest)) = 1; }
void gmp_randinit_lc_2exp (gmp_randstate_t rstate, mpz_srcptr a, unsigned long int c, mp_bitcnt_t m2exp) { gmp_rand_lc_struct *p; mp_size_t seedn = BITS_TO_LIMBS (m2exp); ASSERT_ALWAYS (m2exp != 0); p = __GMP_ALLOCATE_FUNC_TYPE (1, gmp_rand_lc_struct); RNG_STATE (rstate) = (mp_limb_t *) (void *) p; RNG_FNPTR (rstate) = (void *) &Linear_Congruential_Generator; /* allocate m2exp bits of space for p->_mp_seed, and initial seed "1" */ mpz_init2 (p->_mp_seed, m2exp); MPN_ZERO (PTR (p->_mp_seed), seedn); SIZ (p->_mp_seed) = seedn; PTR (p->_mp_seed)[0] = 1; /* "a", forced to 0 to 2^m2exp-1 */ mpz_init (p->_mp_a); mpz_fdiv_r_2exp (p->_mp_a, a, m2exp); /* Avoid SIZ(a) == 0 to avoid checking for special case in lc(). */ if (SIZ (p->_mp_a) == 0) { SIZ (p->_mp_a) = 1; MPZ_NEWALLOC (p->_mp_a, 1)[0] = CNST_LIMB (0); } MPN_SET_UI (p->_cp, p->_cn, c); /* Internally we may discard any bits of c above m2exp. The following code ensures that __GMPN_ADD in lc() will always work. */ if (seedn < p->_cn) p->_cn = (p->_cp[0] != 0); p->_mp_m2exp = m2exp; }
void mpz_neg (mpz_ptr w, mpz_srcptr u) { mp_ptr wp; mp_srcptr up; mp_size_t usize, size; usize = SIZ (u); if (u != w) { size = ABS (usize); wp = MPZ_NEWALLOC (w, size); up = PTR (u); MPN_COPY (wp, up, size); } SIZ (w) = -usize; }
size_t mpz_inp_raw (mpz_ptr x, FILE *fp) { unsigned char csize_bytes[4]; mp_size_t csize, abs_xsize, i; size_t abs_csize; char *cp; mp_ptr xp, sp, ep; mp_limb_t slimb, elimb; if (fp == 0) fp = stdin; /* 4 bytes for size */ if (fread (csize_bytes, sizeof (csize_bytes), 1, fp) != 1) return 0; csize = ( (mp_size_t) csize_bytes[0] << 24) + ((mp_size_t) csize_bytes[1] << 16) + ((mp_size_t) csize_bytes[2] << 8) + ((mp_size_t) csize_bytes[3]); /* Sign extend if necessary. Could write "csize -= ((csize & 0x80000000L) << 1)", but that tickles a bug in gcc 3.0 for powerpc64 on AIX. */ if (sizeof (csize) > 4 && csize & 0x80000000L) csize -= 0x80000000L << 1; abs_csize = ABS (csize); /* round up to a multiple of limbs */ abs_xsize = BITS_TO_LIMBS (abs_csize*8); if (abs_xsize != 0) { xp = MPZ_NEWALLOC (x, abs_xsize); /* Get limb boundaries right in the read, for the benefit of the non-nails case. */ xp[0] = 0; cp = (char *) (xp + abs_xsize) - abs_csize; if (fread (cp, abs_csize, 1, fp) != 1) return 0; if (GMP_NAIL_BITS == 0) { /* Reverse limbs to least significant first, and byte swap. If abs_xsize is odd then on the last iteration elimb and slimb are the same. It doesn't seem extra code to handle that case separately, to save an NTOH. */ sp = xp; ep = xp + abs_xsize-1; for (i = 0; i < (abs_xsize+1)/2; i++) { NTOH_LIMB_FETCH (elimb, ep); NTOH_LIMB_FETCH (slimb, sp); *sp++ = elimb; *ep-- = slimb; } } else { /* It ought to be possible to do the transformation in-place, but for now it's easier to use an extra temporary area. */ mp_limb_t byte, limb; int bits; mp_size_t tpos; mp_ptr tp; TMP_DECL; TMP_MARK; tp = TMP_ALLOC_LIMBS (abs_xsize); limb = 0; bits = 0; tpos = 0; for (i = abs_csize-1; i >= 0; i--) { byte = (unsigned char) cp[i]; limb |= (byte << bits); bits += 8; if (bits >= GMP_NUMB_BITS) { ASSERT (tpos < abs_xsize); tp[tpos++] = limb & GMP_NUMB_MASK; bits -= GMP_NUMB_BITS; ASSERT (bits < 8); limb = byte >> (8 - bits); } } if (bits != 0) { ASSERT (tpos < abs_xsize); tp[tpos++] = limb; } ASSERT (tpos == abs_xsize); MPN_COPY (xp, tp, abs_xsize); TMP_FREE; }
void mpq_set_f (mpq_ptr q, mpf_srcptr f) { mp_size_t fexp = EXP(f); mp_ptr fptr = PTR(f); mp_size_t fsize = SIZ(f); mp_size_t abs_fsize = ABS(fsize); mp_limb_t flow; if (fsize == 0) { /* set q=0 */ SIZ(NUM(q)) = 0; SIZ(DEN(q)) = 1; PTR(DEN(q))[0] = 1; return; } /* strip low zero limbs from f */ flow = *fptr; MPN_STRIP_LOW_ZEROS_NOT_ZERO (fptr, abs_fsize, flow); if (fexp >= abs_fsize) { /* radix point is to the right of the limbs, no denominator */ mp_ptr num_ptr; num_ptr = MPZ_NEWALLOC (mpq_numref (q), fexp); MPN_ZERO (num_ptr, fexp - abs_fsize); MPN_COPY (num_ptr + fexp - abs_fsize, fptr, abs_fsize); SIZ(NUM(q)) = fsize >= 0 ? fexp : -fexp; SIZ(DEN(q)) = 1; PTR(DEN(q))[0] = 1; } else { /* radix point is within or to the left of the limbs, use denominator */ mp_ptr num_ptr, den_ptr; mp_size_t den_size; den_size = abs_fsize - fexp; num_ptr = MPZ_NEWALLOC (mpq_numref (q), abs_fsize); den_ptr = MPZ_NEWALLOC (mpq_denref (q), den_size+1); if (flow & 1) { /* no powers of two to strip from numerator */ MPN_COPY (num_ptr, fptr, abs_fsize); MPN_ZERO (den_ptr, den_size); den_ptr[den_size] = 1; } else { /* right shift numerator, adjust denominator accordingly */ int shift; den_size--; count_trailing_zeros (shift, flow); mpn_rshift (num_ptr, fptr, abs_fsize, shift); abs_fsize -= (num_ptr[abs_fsize-1] == 0); MPN_ZERO (den_ptr, den_size); den_ptr[den_size] = GMP_LIMB_HIGHBIT >> (shift-1); } SIZ(NUM(q)) = fsize >= 0 ? abs_fsize : -abs_fsize; SIZ(DEN(q)) = den_size + 1; } }
/* Get a limb pointer for writing, previous contents may be destroyed. */ mp_limb_t * mpz_limbs_write (mpz_ptr x, mp_size_t n) { assert (n > 0); return MPZ_NEWALLOC (x, n); }
choke me #endif void mpq_set_d (mpq_ptr dest, double d) { int negative; mp_exp_t exp; mp_limb_t tp[LIMBS_PER_DOUBLE]; mp_ptr np, dp; mp_size_t nn, dn; int c; DOUBLE_NAN_INF_ACTION (d, __gmp_invalid_operation (), __gmp_invalid_operation ()); negative = d < 0; d = ABS (d); exp = __gmp_extract_double (tp, d); /* There are two main version of the conversion. The `then' arm handles numbers with a fractional part, while the `else' arm handles integers. */ #if LIMBS_PER_DOUBLE == 4 if (exp <= 1 || (exp == 2 && (tp[0] | tp[1]) != 0)) #endif #if LIMBS_PER_DOUBLE == 3 if (exp <= 1 || (exp == 2 && tp[0] != 0)) #endif #if LIMBS_PER_DOUBLE == 2 if (exp <= 1) #endif { if (d == 0.0) { SIZ(NUM(dest)) = 0; SIZ(DEN(dest)) = 1; PTR(DEN(dest))[0] = 1; return; } #if LIMBS_PER_DOUBLE == 4 np = MPZ_NEWALLOC (NUM(dest), 4); if ((tp[0] | tp[1] | tp[2]) == 0) np[0] = tp[3], nn = 1; else if ((tp[0] | tp[1]) == 0) np[1] = tp[3], np[0] = tp[2], nn = 2; else if (tp[0] == 0) np[2] = tp[3], np[1] = tp[2], np[0] = tp[1], nn = 3; else np[3] = tp[3], np[2] = tp[2], np[1] = tp[1], np[0] = tp[0], nn = 4; #endif #if LIMBS_PER_DOUBLE == 3 np = MPZ_NEWALLOC (NUM(dest), 3); if ((tp[0] | tp[1]) == 0) np[0] = tp[2], nn = 1; else if (tp[0] == 0) np[1] = tp[2], np[0] = tp[1], nn = 2; else np[2] = tp[2], np[1] = tp[1], np[0] = tp[0], nn = 3; #endif #if LIMBS_PER_DOUBLE == 2 np = MPZ_NEWALLOC (NUM(dest), 2); if (tp[0] == 0) np[0] = tp[1], nn = 1; else np[1] = tp[1], np[0] = tp[0], nn = 2; #endif dn = nn + 1 - exp; ASSERT (dn > 0); /* -exp >= -1; nn >= 1*/ dp = MPZ_NEWALLOC (DEN(dest), dn); MPN_ZERO (dp, dn - 1); dp[dn - 1] = 1; count_trailing_zeros (c, np[0] | dp[0]); if (c != 0) { mpn_rshift (np, np, nn, c); nn -= np[nn - 1] == 0; --dn; dp[dn - 1] = CNST_LIMB(1) << (GMP_LIMB_BITS - c); } SIZ(DEN(dest)) = dn; } else { nn = exp; np = MPZ_NEWALLOC (NUM(dest), nn); switch (nn) { default: MPN_ZERO (np, nn - LIMBS_PER_DOUBLE); np += nn - LIMBS_PER_DOUBLE; /* fall through */ #if LIMBS_PER_DOUBLE == 2 case 2: np[1] = tp[1], np[0] = tp[0]; break; #endif #if LIMBS_PER_DOUBLE == 3 case 3: np[2] = tp[2], np[1] = tp[1], np[0] = tp[0]; break; case 2: np[1] = tp[2], np[0] = tp[1]; break; #endif #if LIMBS_PER_DOUBLE == 4 case 4: np[3] = tp[3], np[2] = tp[2], np[1] = tp[1], np[0] = tp[0]; break; case 3: np[2] = tp[3], np[1] = tp[2], np[0] = tp[1]; break; case 2: np[1] = tp[3], np[0] = tp[2]; break; #endif } *PTR(DEN(dest)) = 1; SIZ(DEN(dest)) = 1; } SIZ(NUM(dest)) = negative ? -nn : nn; }
void mpz_gcdext (mpz_ptr g, mpz_ptr s, mpz_ptr t, mpz_srcptr a, mpz_srcptr b) { mp_size_t asize, bsize; mp_ptr tmp_ap, tmp_bp; mp_size_t gsize, ssize, tmp_ssize; mp_ptr gp, tmp_gp, tmp_sp; TMP_DECL; /* mpn_gcdext requires that Usize >= Vsize. Therefore, we often have to swap U and V. The computed cofactor will be the "smallest" one, which is faster to produce. The wanted one will be computed here; this is needed anyway when both are requested. */ asize = ABSIZ (a); bsize = ABSIZ (b); if (asize < bsize) { MPZ_SRCPTR_SWAP (a, b); MP_SIZE_T_SWAP (asize, bsize); MPZ_PTR_SWAP (s, t); } if (bsize == 0) { /* g = |a|, s = sgn(a), t = 0. */ ssize = SIZ (a) >= 0 ? (asize != 0) : -1; gp = MPZ_REALLOC (g, asize); MPN_COPY (gp, PTR (a), asize); SIZ (g) = asize; if (t != NULL) SIZ (t) = 0; if (s != NULL) { SIZ (s) = ssize; MPZ_NEWALLOC (s, 1)[0] = 1; } return; } TMP_MARK; TMP_ALLOC_LIMBS_2 (tmp_ap, asize, tmp_bp, bsize); MPN_COPY (tmp_ap, PTR (a), asize); MPN_COPY (tmp_bp, PTR (b), bsize); TMP_ALLOC_LIMBS_2 (tmp_gp, bsize, tmp_sp, bsize + 1); gsize = mpn_gcdext (tmp_gp, tmp_sp, &tmp_ssize, tmp_ap, asize, tmp_bp, bsize); ssize = ABS (tmp_ssize); tmp_ssize = SIZ (a) >= 0 ? tmp_ssize : -tmp_ssize; if (t != NULL) { mpz_t x; __mpz_struct gtmp, stmp; PTR (>mp) = tmp_gp; SIZ (>mp) = gsize; PTR (&stmp) = tmp_sp; SIZ (&stmp) = tmp_ssize; MPZ_TMP_INIT (x, ssize + asize + 1); mpz_mul (x, &stmp, a); mpz_sub (x, >mp, x); mpz_divexact (t, x, b); } if (s != NULL) { mp_ptr sp; sp = MPZ_REALLOC (s, ssize); MPN_COPY (sp, tmp_sp, ssize); SIZ (s) = tmp_ssize; } gp = MPZ_REALLOC (g, gsize); MPN_COPY (gp, tmp_gp, gsize); SIZ (g) = gsize; TMP_FREE; }
void mpz_powm_sec (mpz_ptr r, mpz_srcptr b, mpz_srcptr e, mpz_srcptr m) { mp_size_t n; mp_ptr rp, tp; mp_srcptr bp, ep, mp; mp_size_t rn, bn, es, en; TMP_DECL; n = ABSIZ(m); mp = PTR(m); if (UNLIKELY ((n == 0) || (mp[0] % 2 == 0))) DIVIDE_BY_ZERO; es = SIZ(e); if (UNLIKELY (es <= 0)) { if (es == 0) { /* b^0 mod m, b is anything and m is non-zero. Result is 1 mod m, i.e., 1 or 0 depending on if m = 1. */ SIZ(r) = n != 1 || mp[0] != 1; MPZ_NEWALLOC (r, 1)[0] = 1; return; } DIVIDE_BY_ZERO; } en = es; bn = ABSIZ(b); if (UNLIKELY (bn == 0)) { SIZ(r) = 0; return; } TMP_MARK; tp = TMP_ALLOC_LIMBS (n + mpn_sec_powm_itch (bn, en * GMP_NUMB_BITS, n)); rp = tp; tp += n; bp = PTR(b); ep = PTR(e); mpn_sec_powm (rp, bp, bn, ep, en * GMP_NUMB_BITS, mp, n, tp); rn = n; MPN_NORMALIZE (rp, rn); if ((ep[0] & 1) && SIZ(b) < 0 && rn != 0) { mpn_sub (rp, PTR(m), n, rp, rn); rn = n; MPN_NORMALIZE (rp, rn); } MPZ_REALLOC (r, rn); SIZ(r) = rn; MPN_COPY (PTR(r), rp, rn); TMP_FREE; }
void mpz_mfac_uiui (mpz_ptr x, unsigned long n, unsigned long m) { ASSERT (n <= GMP_NUMB_MAX); ASSERT (m != 0); if ((n < 3) | (n - 3 < m - 1)) { /* (n < 3 || n - 1 <= m || m == 0) */ PTR (x)[0] = n + (n == 0); SIZ (x) = 1; } else { /* m < n - 1 < GMP_NUMB_MAX */ mp_limb_t g, sn; mpz_t t; sn = n; g = mpn_gcd_1 (&sn, 1, m); if (g > 1) { n/=g; m/=g; } if (m <= 2) { /* fac or 2fac */ if (m == 1) { if (g > 2) { mpz_init (t); mpz_fac_ui (t, n); sn = n; } else { if (g == 2) mpz_2fac_ui (x, n << 1); else mpz_fac_ui (x, n); return; } } else { /* m == 2 */ if (g > 1) { mpz_init (t); mpz_2fac_ui (t, n); sn = n / 2 + 1; } else { mpz_2fac_ui (x, n); return; } } } else { /* m >= 3, gcd(n,m) = 1 */ mp_limb_t *factors; mp_limb_t prod, max_prod, j; TMP_DECL; sn = n / m + 1; j = 0; prod = n; n -= m; max_prod = GMP_NUMB_MAX / n; if (g > 1) factors = MPZ_NEWALLOC (x, sn / log_n_max (n) + 2); else { TMP_MARK; factors = TMP_ALLOC_LIMBS (sn / log_n_max (n) + 2); } for (; n > m; n -= m) FACTOR_LIST_STORE (n, prod, max_prod, factors, j); factors[j++] = n; factors[j++] = prod; if (g > 1) { mpz_init (t); mpz_prodlimbs (t, factors, j); } else { mpz_prodlimbs (x, factors, j); TMP_FREE; return; } } { mpz_t p; mpz_init (p); mpz_ui_pow_ui (p, g, sn); /* g^sn */ mpz_mul (x, p, t); mpz_clear (p); mpz_clear (t); } } }