def test_time_init_gmpy(self): if gmpy is None: raise SkipTest t = param.Time(time_type=gmpy.mpq) self.assertEqual(t(), gmpy.mpq(0)) t.advance(gmpy.mpq(0.25)) self.assertEqual(t(), gmpy.mpq(1,4))
def processInvoice(self, doc): # # Compute totals etc # self.lines = self.invoice.getLines() total_price = gmpy.mpq(0) for line in self.lines: total_price += line.getPriceVat0() # total price self.total_price_pre_discount_vat0 = total_price # partner discount self.partner_discount = invoicing.compute_partner_discount_oct2007(self.total_price_pre_discount_vat0) # total price after discount self.total_price_vat0 = self.total_price_pre_discount_vat0 - self.partner_discount # VAT self.total_vat = self.total_price_vat0 * self.vat_percentage / gmpy.mpq(100) # total after discount, with VAT self.total_price_vat = self.total_price_vat0 + self.total_vat # # Process replacements and generate row elements # self._process_replacements(doc)
def test_time_init_gmpy(self): if gmpy is None: raise SkipTest t = param.Time(time_type=gmpy.mpq) self.assertEqual(t(), gmpy.mpq(0)) t.advance(gmpy.mpq(0.25)) self.assertEqual(t(), gmpy.mpq(1, 4))
def bernoulli(n): """ Returns recursively the nth bernoulli number as a fraction. """ if n <= 0: return 1 if n == 1: return gmpy.mpq(-1,2) if (n%2) == 1: return 0 return -gmpy.mpq(sum(map(lambda x:gmpy.bincoef(n+1, x)*bernoulli(x), range(n))), n+1)
def __init__(self, xx, yy): ''' Initializes a Lagrange interpolation polynomial by supplying corresponding x and y values ''' self.xx = [ gmpy.mpq(x) for x in xx ] self.yy = [ gmpy.mpq(y) for y in yy ] assert len(self.xx) == len(self.yy), "xx and yy have to be the same size"
def gao(i=2,t=mpq('1/2')): if t==0: print 'found' return 1 if i==N+1 or t<0 or psum[i]<t: return 0 # hsh=(i,t) # if hsh in mem: return mem[hsh] total = gao(i+1,t) + gao(i+1,t-mpq(1)/mpq(i*i)) # mem[hsh]=total return total
def gao(i=2, t=mpq('1/2')): if t == 0: print 'found' return 1 if i == N + 1 or t < 0 or psum[i] < t: return 0 # hsh=(i,t) # if hsh in mem: return mem[hsh] total = gao(i + 1, t) + gao(i + 1, t - mpq(1) / mpq(i * i)) # mem[hsh]=total return total
def test_time_hashing_rationals_gmpy(self): """ Check that hashes of fractions and gmpy mpqs match for some reasonable rational numbers. """ if gmpy is None: raise SkipTest pi = "3.141592" hashfn = numbergen.Hash("test", input_count=1) self.assertEqual(hashfn(0.5), hashfn(gmpy.mpq(0.5))) self.assertEqual(hashfn(pi), hashfn(gmpy.mpq(3.141592)))
def bernoulli(n): """ Returns recursively the nth bernoulli number as a fraction. """ if n <= 0: return 1 if n == 1: return gmpy.mpq(-1, 2) if (n % 2) == 1: return 0 return -gmpy.mpq( sum(map(lambda x: gmpy.bincoef(n + 1, x) * bernoulli(x), range(n))), n + 1)
def verify_sin_cos(N, PS, QS, bits): X = FixedPointBound(bits, mpq(1, 16), 0) m = 2 while m * m < N: m += 2 T = [None] * (m + 1) T[1] = X.mul(X) T[2] = T[1].mul(T[1]) for k in range(4, m + 1, 2): T[k - 1] = T[k // 2].mul(T[k // 2 - 1]) T[k] = T[k // 2].mul(T[k // 2]) for cosorsin in range(2): S = FixedPointBound(bits, 0, 0) for k in range(N - 1, -1, -1): c, d, e = PS[2 * k + cosorsin], QS[2 * k + cosorsin], QS[2 * k + cosorsin + 2] if d != e and k < N - 1: # if alternating, adding e must give a nonnegative number S.check_le_int(e) # adding e must not overflow S.add(e).check_overflow_1() S = S.div(e) # if alternating, adding 1 must not overflow S.add(1).check_overflow_1() if k % m == 0: # if alternating, adding c must give a nonnegative number S.check_le_int(c) S = S.add(c) S.check_overflow_1() if k != 0: S = S.mul(T[m]) S.check_overflow_1() else: S = S.addmul(T[k % m], c) S.check_overflow_1() if cosorsin == 0: S = S.div(mpq(QS[0])) S.check_overflow_1() # note: top limb must actually be 0 or 1; # but this follows by S.rad <= 2 print N, float(S.mid), float(S.rad) assert S.rad <= 2 else: S = S.div(mpq(QS[0])) S.check_overflow_1() S = S.mul(X) S.check_overflow_0() print N, float(S.mid), float(S.rad) assert S.rad <= 2
def HG_split_diode_coefficient_analytical(n1,n2): """ Using an analytical equation to compute beat coefficients betwween mode n1 and n2 on a split photo detector. Uses arbitrary precision (from gmpy) because otherwise errors get very large for n1,n2>30. This is for comparison with the numerical method HG_split_diode_coefficient_numerical only. """ import gmpy temp=gmpy.mpq(0.0) for l in np.arange(0,n1/2+1): for k in np.arange(0,(n2-1)/2+1): temp += gmpy.mpq(pow((-1.0/4.0),l+k)*gmpy.mpz(factorial((n2+n1-1)/2-l-k))/gmpy.mpz((factorial(l)*factorial(k)*factorial(n1-2*l)*factorial(n2-2*k)))) c_n1n2=gmpy.mpq(temp*gmpy.mpq(math.sqrt(2.0**(n1+n2)*gmpy.mpz(factorial(n1)*factorial(n2))/np.pi))) return float(gmpy.mpf(c_n1n2))
def test_time_hashing_integers_gmpy(self): """ Check that hashes for gmpy values at the integers also matches those of ints, fractions and strings. """ if gmpy is None: raise SkipTest hashfn = numbergen.Hash("test", input_count=1) hash_1 = hashfn(1) hash_42 = hashfn(42) self.assertEqual(hash_1, hashfn(gmpy.mpq(1))) self.assertEqual(hash_1, hashfn(1)) self.assertEqual(hash_42, hashfn(gmpy.mpq(42))) self.assertEqual(hash_42, hashfn(42))
def verify_sin_cos(N, PS, QS, bits): X = FixedPointBound(bits, mpq(1,16), 0) m = 2 while m * m < N: m += 2 T = [None] * (m+1) T[1] = X.mul(X) T[2] = T[1].mul(T[1]) for k in range(4, m + 1, 2): T[k-1] = T[k//2].mul(T[k//2-1]) T[k] = T[k//2].mul(T[k//2]) for cosorsin in range(2): S = FixedPointBound(bits, 0, 0) for k in range(N-1, -1, -1): c, d, e = PS[2*k+cosorsin], QS[2*k+cosorsin], QS[2*k+cosorsin+2] if d != e and k < N-1: # if alternating, adding e must give a nonnegative number S.check_le_int(e) # adding e must not overflow S.add(e).check_overflow_1() S = S.div(e) # if alternating, adding 1 must not overflow S.add(1).check_overflow_1() if k % m == 0: # if alternating, adding c must give a nonnegative number S.check_le_int(c) S = S.add(c) S.check_overflow_1() if k != 0: S = S.mul(T[m]) S.check_overflow_1() else: S = S.addmul(T[k % m], c) S.check_overflow_1() if cosorsin == 0: S = S.div(mpq(QS[0])) S.check_overflow_1() # note: top limb must actually be 0 or 1; # but this follows by S.rad <= 2 print N, float(S.mid), float(S.rad) assert S.rad <= 2 else: S = S.div(mpq(QS[0])) S.check_overflow_1() S = S.mul(X) S.check_overflow_0() print N, float(S.mid), float(S.rad) assert S.rad <= 2
def share(cls, D, k, n, P=None): ''' Generates shares for a secret consisting of a natural number z ∈ N D: Secret number k: Amount of shares needed to reconstruct D n: Amount of unique shares to create P: Finite field size, must be prime Constraints: P > D and P > n if P is None then a suitable prime will be generated Returns: (P, shares) ''' if P is None or not is_probable_prime(P): P = generate_prime_bigger_than(random.randint(max(D, n),100000000*max(D, n))) assert P > D, "P must be bigger than D" assert P > n, "P must be bigger than n" assert D >= 0, "D must be non-negative" if D > 0: a = [ random.randint(0, D-1) for _ in range(k-1) ] + [D] else: a = [ random.randint(0, 1000) for _ in range(k-1) ] + [D] shares = [] for i in range(n): x = i+1 D_i = gmpy.mpq(cls.polyval(a, P, x)) if D_i.denominator == 1: D_i = int(gmpy.mpz(D_i)) shares.append( (x, D_i) ) return (P, shares)
def _mpq_pickle_support(): """Allow instances of gmpy.mpq to pickle.""" from gmpy import mpq mpq_type = type(mpq( 1, 10)) # gmpy doesn't appear to expose the type another way import copy_reg copy_reg.pickle(mpq_type, lambda q: (mpq, (q.digits(), )))
def go(w, h, d, x, y): x = gmpy.mpq(x) y = gmpy.mpq(y) angles = set() four = list(itertools.product([x, 2 * w - x], [y, 2 * h - y])) for i in xrange(-55, 55): for j in xrange(-55, 55): for x1, y1 in four: x2, y2 = x1 + 2 * w * i, y1 + 2 * h * j if (x - x2) ** 2 + (y - y2) ** 2 <= d * d + 1e-9: if x != x2: angles.add((sign(x - x2), (y - y2) / (x - x2))) else: angles.add((sign(y - y2), "inf")) angles.remove((0, "inf")) return len(angles)
def polyval(cls, a, x): ''' Evaluates secret polynomial consisting of coefficients a at x ''' y = gmpy.mpq(0) for i, a_i in enumerate(reversed(a)): y += a_i*x**i return y
def _mpq_pickle_support(): """Allow instances of gmpy.mpq to pickle.""" from gmpy import mpq mpq_type = type(mpq(1, 10)) # gmpy doesn't appear to expose the type another way import copy_reg copy_reg.pickle(mpq_type, lambda q: (mpq, (q.digits(),)))
def pi_gen(): x = 0 n = 1 while 1: p = mpq((120*n-89)*n+16, (((512*n-1024)*n+712)*n-206)*n+21) x = mod1(16*x + p) n += 1 yield int(16*x)
def test_time_init_gmpy_advanced(self): if gmpy is None: raise SkipTest t = param.Time(time_type=gmpy.mpq, timestep=gmpy.mpq(0.25), until=1.5) self.assertEqual(t(), gmpy.mpq(0,1)) t(0.5) self.assertEqual(t(), gmpy.mpq(1,2)) with t: t.advance(0.25) self.assertEqual(t(), gmpy.mpq(3,4)) self.assertEqual(t(), gmpy.mpq(1,2)) tvals = [tval for tval in t] self.assertEqual(tvals, [gmpy.mpq(1,2), gmpy.mpq(3,4), gmpy.mpq(1,1), gmpy.mpq(5,4), gmpy.mpq(3,2)])
def pi_gen(): x = 0 n = 1 while 1: p = mpq((120 * n - 89) * n + 16, (((512 * n - 1024) * n + 712) * n - 206) * n + 21) x = mod1(16 * x + p) n += 1 yield int(16 * x)
def test_time_init_gmpy_advanced(self): if gmpy is None: raise SkipTest t = param.Time(time_type=gmpy.mpq, timestep=gmpy.mpq(0.25), until=1.5) self.assertEqual(t(), gmpy.mpq(0, 1)) t(0.5) self.assertEqual(t(), gmpy.mpq(1, 2)) with t: t.advance(0.25) self.assertEqual(t(), gmpy.mpq(3, 4)) self.assertEqual(t(), gmpy.mpq(1, 2)) tvals = [tval for tval in t] self.assertEqual(tvals, [ gmpy.mpq(1, 2), gmpy.mpq(3, 4), gmpy.mpq(1, 1), gmpy.mpq(5, 4), gmpy.mpq(3, 2) ])
def atan_coefficients(NN, bits): ps = [] qs = [] temp = [] Q = 1 for k in range(2 * NN + 50): p = 1 q = 2 * k + 1 if lcm(Q, q) < 2**bits: temp.append(mpq(p, q)) Q = lcm(Q, q) else: for a in temp: ps.append(int(a * Q)) qs.append(int(Q)) Q = q temp = [mpq(p, q)] return ps[:NN], qs[:NN]
def polyval(cls, a, p, x): ''' Evaluates secret polynomial consisting of coefficients a at x modulo P ''' y = gmpy.mpq(0) for i, a_i in enumerate(reversed(a)): y += (a_i * ((x**i) % p)) % p y %= p return y
def atan_coefficients(NN, bits): ps = [] qs = [] temp = [] Q = 1 for k in range(2*NN+50): p = 1 q = 2*k+1 if lcm(Q, q) < 2**bits: temp.append(mpq(p,q)) Q = lcm(Q, q) else: for a in temp: ps.append(int(a * Q)) qs.append(int(Q)) Q = q temp = [mpq(p,q)] return ps[:NN], qs[:NN]
def unpickle_mp(value): type, value = value if type == 'z': return mpz(value) elif type == 'q': return mpq(value) elif type == 'f': return g_mpf(value) else: return value
def test_sympify_gmpy(): try: import gmpy except ImportError: pass else: value = sympify(gmpy.mpz(1000001)) assert value == Integer(1000001) and type(value) is Integer value = sympify(gmpy.mpq(101, 127)) assert value == Rational(101, 127) and type(value) is Rational
def _at(self, x): ''' Computes polynomial value L(x) modulo P ''' k = len(self.xx) z = gmpy.mpq(0) for j in range(k): y = self.yy[j] b = self._base(j,x) z += (y*b) z %= self.P return z
def _format_gmpy_price(self, x, eurosign=True): t = x * gmpy.mpq(100) # 123.4567 -> 12345.67 t = int(gmpy.digits(t)) # 12345 full = t / 100 part = t % 100 esign = '' if eurosign: esign = u' \u20ac' if full == 0: return u'0,%02d%s' % (part, esign) else: return u'%d,%02d%s' % (full, part, esign)
def bernoulli(m): assert m >= 0 if m == 0: return 1 if m == 1: return -mpq(1, 2) if m % 6 == 0: return b0mod6(m) if m % 6 == 2: return b2mod6(m) if m % 6 == 4: return b4mod6(m) return 0
def verify_atan(N, PS, QS, bits): X = FixedPointBound(bits, mpq(1,16), 0) S = FixedPointBound(bits, 0, 0) m = 2 while m * m < N: m += 2 T = [None] * (m+1) T[1] = X.mul(X) T[2] = T[1].mul(T[1]) for k in range(4, m + 1, 2): T[k-1] = T[k//2].mul(T[k//2-1]) T[k] = T[k//2].mul(T[k//2]) for k in range(N-1, -1, -1): c, d, e = PS[k], QS[k], QS[k+1] if d != e and k < N-1: # if alternating, adding e must give a nonnegative number S.check_le_int(e) # adding e must not overflow S.add(e).check_overflow_1() S = S.mul(d).div(e) # if alternating, adding d must not overflow S.add(d).check_overflow_1() if k % m == 0: # if alternating, adding c must give a nonnegative number S.check_le_int(c) S = S.add(c) S.check_overflow_1() if k != 0: S = S.mul(T[m]) S.check_overflow_1() else: S = S.addmul(T[k % m], c) S.check_overflow_1() S = S.div(mpq(QS[0])) S = S.mul(X) S.check_overflow_0() print N, float(S.mid), float(S.rad) assert S.rad <= 2
def verify_atan(N, PS, QS, bits): X = FixedPointBound(bits, mpq(1, 16), 0) S = FixedPointBound(bits, 0, 0) m = 2 while m * m < N: m += 2 T = [None] * (m + 1) T[1] = X.mul(X) T[2] = T[1].mul(T[1]) for k in range(4, m + 1, 2): T[k - 1] = T[k // 2].mul(T[k // 2 - 1]) T[k] = T[k // 2].mul(T[k // 2]) for k in range(N - 1, -1, -1): c, d, e = PS[k], QS[k], QS[k + 1] if d != e and k < N - 1: # if alternating, adding e must give a nonnegative number S.check_le_int(e) # adding e must not overflow S.add(e).check_overflow_1() S = S.mul(d).div(e) # if alternating, adding d must not overflow S.add(d).check_overflow_1() if k % m == 0: # if alternating, adding c must give a nonnegative number S.check_le_int(c) S = S.add(c) S.check_overflow_1() if k != 0: S = S.mul(T[m]) S.check_overflow_1() else: S = S.addmul(T[k % m], c) S.check_overflow_1() S = S.div(mpq(QS[0])) S = S.mul(X) S.check_overflow_0() print N, float(S.mid), float(S.rad) assert S.rad <= 2
def mul(self, other): if isinstance(other, FixedPointBound): MAX_ULP = mpq(1, 2**self.bits) mid = self.mid * other.mid rad = 0 rad += self.rad * other.mid # ulp rad += self.mid * other.rad # ulp rad += self.rad * other.rad * MAX_ULP # ulp rad += 1 # ulp rounding else: assert other == int(other) and other >= 0 mid = self.mid * int(other) rad = self.rad * int(other) return FixedPointBound(self.bits, mid, rad)
def _base(self, j, x): ''' Compute value of base polynomial l_j at position x j: Index of base polynomial x: Position to evaluate polynomial at ''' l = 1 k = len(self.xx) x = gmpy.mpq(x) for m in range(k): if j==m: continue l *= (x-self.xx[m])/(self.xx[j]-self.xx[m]) return l
def share(cls, D, k, n): ''' Generates shares for a secret consisting of a natural number z ∈ N D: Secret number k: Amount of shares needed to reconstruct D n: Amount of unique shares to create Returns pairs of (x,f(x)) ''' # Prepare polynomial a = [ random.randint(-D,D) for _ in range(k-1) ] + [D] for i in range(n): x = i+1 D_i = gmpy.mpq(cls.polyval(a, x)) if D_i.denominator == 1: D_i = gmpy.mpz(D_i) yield (x, D_i)
def perplexity(probs, words): global use_fractions print "perplexity use_fractions: %s" % use_fractions n = len(probs) - 1 if use_fractions: prob = gmpy.mpq(1,1) else: prob = 0 word_list = [] i = 0 for w in words: i += 1 if i % 10000 == 0: print "processing word %d" % i word_list.append(w) if len(word_list) > n: word_list.pop(0) temp_words = list(word_list) while(True): if tuple(temp_words) in probs[len(temp_words)]: if use_fractions: prob *= probs[len(temp_words)][tuple(temp_words)] else: prob += probs[len(temp_words)][tuple(temp_words)] break else: unk_gram = list(temp_words[:-1]) unk_gram.append(filters.UNK) if tuple(unk_gram) in probs[len(unk_gram)]: if use_fractions: prob *= probs[len(unk_gram)][tuple(unk_gram)] else: prob += probs[len(unk_gram)][tuple(unk_gram)] break else: temp_words.pop(0) print "prob= %s" % prob print "len(words)= %s" % len(words) if use_fractions: print "Computing perplexity with arbitrary precision" return mp.power((mp.mpf(prob.denom())/mp.mpf(prob.numer())), 1.0/len(words)) else: print "Computing perplexity with logarithms" return math.exp(-prob/len(words))
def intersects(i, j): xi1,yi1,xi2,yi2=p[i][0],p[i][1],p[i][2],p[i][3] xj1,yj1,xj2,yj2=p[j][0],p[j][1],p[j][2],p[j][3] if sgn(sgn((xj1-xi1)*(yi2-yi1)-(xi2-xi1)*(yj1-yi1)) * sgn((xj2-xi1)*(yi2-yi1)-(xi2-xi1)*(yj2-yi1))) >= 0: return False if sgn(sgn((xi1-xj1)*(yj2-yj1)-(xj2-xj1)*(yi1-yj1)) * sgn((xi2-xj1)*(yj2-yj1)-(xj2-xj1)*(yi2-yj1))) >= 0: return False xp=None if xi2==xi1: xp=xi1 else: mi=mpq(yi2-yi1)/mpq(xi2-xi1) if xj2==xj1: xp=xj1 else: mj=mpq(yj2-yj1)/mpq(xj2-xj1) if xp==None: xp=mpq(yj1-yi1+mi*xi1-mj*xj1)/mpq(mi-mj) if xi1!=xi2: yp=mi*(xp-xi1)+yi1 else: yp=mj*(xp-xj1)+yj1 return (xp,yp)
def compute_partner_discount_oct2007(monthly_inv_vat0): t = gmpy.mpq(monthly_inv_vat0) disc = gmpy.mpq(0) # cumulative discount is computed starting from highest # discount rate for [limit, percentage] in [[10000, 30], [5000, 25], [2500, 20], [1000, 15], [500, 10]]: excess = t - gmpy.mpq(limit) if excess > gmpy.mpq(0): disc += excess * gmpy.mpq(percentage) / gmpy.mpq(100) t = limit return disc
def dec_to_str(x): ''' Converts base 257 number to bytes ''' l = [] running = gmpy.mpq(x) if x > 0: # Find count of digits of number in base 257 by computing log_257(x) i = int(np.ceil(np.log10(float(x))/np.log10(257)))+1 else: return '' # To account for float-inaccuracies, find correct bound via integer # based computations while x//257**i == 0: i -= 1 while running > 0: q, r = divmod(running, 257**i) l.append(chr(int(q-1))) running = r i -= 1 return "".join(l)
def compute_partner_discount_oct2007(monthly_inv_vat0): t = gmpy.mpq(monthly_inv_vat0) disc = gmpy.mpq(0) # cumulative discount is computed starting from highest # discount rate for [limit, percentage] in [ [ 10000, 30 ], [ 5000, 25 ], [ 2500, 20 ], [ 1000, 15 ], [ 500, 10 ] ]: excess = t - gmpy.mpq(limit) if excess > gmpy.mpq(0): disc += excess * gmpy.mpq(percentage) / gmpy.mpq(100) t = limit return disc
def probabilities(ngrams): global use_fractions print "probabilities use_fractions: %s" % use_fractions totals = [dict_sum(x) for x in ngrams] probabilities = [] prevgram = None for ngram in ngrams: d = {} for k in ngram.keys(): prefix = k[0:-1] numer = ngram[k] if prefix in prevgram: # more than unigram denom = prevgram[prefix] else: denom = totals[1] if use_fractions: d[k] = gmpy.mpq(numer, denom) else: d[k] = log(numer) - log(denom) probabilities.append(d) prevgram = ngram return probabilities
def intersects(i, j): xi1, yi1, xi2, yi2 = p[i][0], p[i][1], p[i][2], p[i][3] xj1, yj1, xj2, yj2 = p[j][0], p[j][1], p[j][2], p[j][3] if sgn( sgn((xj1 - xi1) * (yi2 - yi1) - (xi2 - xi1) * (yj1 - yi1)) * sgn((xj2 - xi1) * (yi2 - yi1) - (xi2 - xi1) * (yj2 - yi1))) >= 0: return False if sgn( sgn((xi1 - xj1) * (yj2 - yj1) - (xj2 - xj1) * (yi1 - yj1)) * sgn((xi2 - xj1) * (yj2 - yj1) - (xj2 - xj1) * (yi2 - yj1))) >= 0: return False xp = None if xi2 == xi1: xp = xi1 else: mi = mpq(yi2 - yi1) / mpq(xi2 - xi1) if xj2 == xj1: xp = xj1 else: mj = mpq(yj2 - yj1) / mpq(xj2 - xj1) if xp == None: xp = mpq(yj1 - yi1 + mi * xi1 - mj * xj1) / mpq(mi - mj) if xi1 != xi2: yp = mi * (xp - xi1) + yi1 else: yp = mj * (xp - xj1) + yj1 return (xp, yp)
#!/usr/bin/python3 # -*- coding: utf-8 -*- # Aradığımız kesir 3/7'ye çok yakın olacağından n'i 1'den 10^6'ya kadar arttırırken m'i de n/m~=3/7 olacak şekilde m=7n/3 ile başlatıp 3/7'ye çok yakın olan 299999/700000 ile kıyaslıyoruz. from gmpy import mpq liste = set() LIMIT = 10**6 for n in range(1, LIMIT+1): for m in range((7*n//3), LIMIT+1): if(mpq(n,m)<mpq(299999,700000)): break if(mpq(n,m)>mpq(3,7)): continue liste.add(mpq(n,m)) p = sorted(liste).index(mpq(3,7)) print(sorted(liste)[p-1])
for k in [ -1, 1, 7, 11, -(2**15), 2**16, 2**30, 2**31, 2**32, 2**33, 2**61, -(2**62), 2**63, 2**64 ]: val = k * (s + i) assert hash(val) == hash(gmpy.mpz(val)) print("hash tests for integer values passed") for d in [1, -2, 3, -47, m, m * 2]: for s in [0, m // 2, m, m * 2, m * m]: for i in range(-10, 10): for k in [ -1, 1, 7, 11, -(2**15), 2**16, 2**30, 2**31, 2**32, 2**33, 2**61, -(2**62), 2**63, 2**64 ]: val = k * (s + i) if val: assert hash(fractions.Fraction(d, val)) == hash( gmpy.mpq(d, val)), (d, val, hash(fractions.Fraction(d, val)), hash(gmpy.mpq(d, val))) if d: assert hash(fractions.Fraction(val, d)) == hash( gmpy.mpq(val, d)), (val, d, hash(fractions.Fraction(val, d)), hash(gmpy.mpq(val, d))) print("hash tests for rational values passed")
def div(self, other): assert other == int(other) and other >= 0 mid = self.mid / mpq(other) rad = self.rad / mpq(other) + 1 return FixedPointBound(self.bits, mid, rad)
def __init__(self, bits, mid, rad): self.bits = bits self.mid = mpq(mid) self.rad = mpq(rad) # rad is in ulp
#!/usr/bin/python3 # -*- coding: utf-8 -*- # Aradığımız kesir 3/7'ye çok yakın olacağından n'i 1'den 10^6'ya kadar arttırırken m'i de n/m~=3/7 olacak şekilde m=7n/3 ile başlatıp 3/7'ye çok yakın olan 299999/700000 ile kıyaslıyoruz. from gmpy import mpq liste = set() LIMIT = 10**6 for n in range(1, LIMIT + 1): for m in range((7 * n // 3), LIMIT + 1): if (mpq(n, m) < mpq(299999, 700000)): break if (mpq(n, m) > mpq(3, 7)): continue liste.add(mpq(n, m)) p = sorted(liste).index(mpq(3, 7)) print(sorted(liste)[p - 1])
def check_le_int(self, c): # check that |self| <= c MAX_ULP = mpq(1, 2**self.bits) assert self.mid + self.rad * MAX_ULP <= c
def CalculateProbability(a, b, c, d): return mpq(bincoef(a + b, a) * bincoef(c + d, c), bincoef(a + b + c + d, a + c))
# or better to allow decimal/most-anything-else interoperability!-) # relies on Tim Peters' "doctest.py" test-driver r''' >>> filter(lambda x: not x.startswith('__'), dir(f)) ['_copy', 'binary', 'ceil', 'digits', 'f2q', 'floor', 'getprec', 'getrprec', 'qdiv', 'reldiff', 'round', 'setprec', 'sign', 'sqrt', 'trunc'] >>> ''' try: import decimal as _d except ImportError: _d = None import gmpy as _g, doctest, sys __test__ = {} f = _g.mpf('123.456') q = _g.mpq('789123/1000') z = _g.mpz('234') if _d: d = _d.Decimal('12.34') __test__['elemop']=\ r''' >>> print _g.mpz(23) == _d.Decimal(23) True >>> print _g.mpz(d) 12 >>> print _g.mpq(d) 617/50 >>> print _g.mpf(d) 12.34 >>> print f+d 135.796
def check_overflow_0(self): # check that self fits 0 integral limbs MAX_ULP = mpq(1, 2**self.bits) assert self.mid + self.rad * MAX_ULP < 1 - MAX_ULP
def CalculateProbability(a, b, c, d): return mpq( bincoef(a + b, a) * bincoef(c + d, c), bincoef(a + b + c + d, a + c))
def check_overflow_1(self): # check that self fits 1 integral limb MAX_ULP = mpq(1, 2**self.bits) assert self.mid + self.rad * MAX_ULP < 2**self.bits - MAX_ULP