def create(self): ctx = gmpy2.ieee(self.length * 8) # Emulate IEEE for requested format size ctx.round = self.rmodeo # Set the requested gmpy2 rounding mode gmpy2.set_context(ctx) # Make this the active context. # Convert the floating point string to an mpfr object return gmpy2.mpfr(self.fpstr)
def initConstants(cls): from math import sqrt def nextPrime(n=2): while True: for factor in range(2,int(sqrt(n))+1): if n % factor == 0: break else: yield n n += 1 # Find the first nRounds primes npgen = nextPrime() primes = [next(npgen) for x in range(cls.nRounds)] fb_mul = 2 ** cls.wordBits def getFractionalBits(n): return int((n - int(n)) * fb_mul) if cls.use_gmp: from gmpy2 import context,set_context,sqrt,cbrt set_context(context(precision=75)) else: cbrt = lambda n: pow(n, 1 / 3) # First wordBits bits of the fractional parts of the square roots of the first 8 primes H = (getFractionalBits(sqrt(n)) for n in primes[:8]) # First wordBits bits of the fractional parts of the cube roots of the first nRounds primes K = (getFractionalBits(cbrt(n)) for n in primes) cls.H_init = tuple(H) cls.K = tuple(K)
def main23(N): c=gmpy2.context() c.precision=len(str(N))+20 c.real_prec=len(str(N))+20 gmpy2.set_context(c) assert N==gmpy2.mpz(N) N=gmpy2.mpz(N) A=find_sqrt(6*N) A = gmpy2.mpz(A) assert ( (A-1)**2<6*N<A**2 ),'not found' Atag = A for iA in xrange(-2**20,2**20): A = Atag + iA s =A**2-N x = gmpy2.sqrt(s) try: x = gmpy2.mpz(x) except:continue '''print x**2 > s , x**2 < s while x**2>s: x-=1 print 1, print x**2 > s , x**2 < s''' for p in [(A-x)/2,(A-x)/3,(A+x)/2,(A+x)/3 ]: q = N/p if p*q==N: print gmpy2.is_prime(q) print gmpy2.is_prime(p) print min(p,q) assert False,'bla'
def main(N): c=gmpy2.context() c.precision=len(str(N))+20 c.real_prec=len(str(N))+20 gmpy2.set_context(c) assert N==gmpy2.mpz(N) N=gmpy2.mpz(N) A=find_sqrt(N) A = gmpy2.mpz(A) assert ( (A-1)**2<N<A**2 ),'not found' Atag = A for iA in xrange(-2**20,2**20): A = Atag + iA s =A**2-N x = gmpy2.sqrt(s) try: x = gmpy2.mpz(x) except:continue print x**2 > s , x**2 < s '''while x**2>s: x-=1 print 1,''' print x**2 > s , x**2 < s p = A-x q = A+x q = N/p if p*q==N: print gmpy2.is_prime(q) print gmpy2.is_prime(p) print min(p,q) break
def set_prec(prc=None): """ set the precision pass None to get current precision prc is the number of digits that should be accurate in base two """ #note: # precision is defined in base 2. It needs to be redefined in the base # that is being used so as the number in the new base so it doesn't lose # precision. That is, the number shouldn't return with trailing garbage # (45.0000000000000000052...). The conversions are automatically done in # the functions that need the precision - it is not done here. global prec if prc is None: return prec prc = int(abs(prc)) if backend == 'mpmath': # base ten precision mp.prec = int(prc * log(2, 10)) elif backend == 'gmpy2': # base two precision gm.set_context(gm.context(precision=prc)) elif backend == 'decimal': # base ten precision dm.getcontext().prec = int(prc * log(2, 10)) else: pass prec = prc return prc
def create(self, string, round=0): ctx = gmpy2.ieee(self.format) ctx.round = MPFR_Data.rounding[round] gmpy2.set_context(ctx) fpo = gmpy2.mpfr(string) ctx = gmpy2.get_context() # Get the results self.ctx = ctx.copy() # Copy the context for later status return fpo
def create(self,string,round=0): ctx=gmpy2.ieee(self.format) ctx.round=MPFR_Data.rounding[round] gmpy2.set_context(ctx) fpo=gmpy2.mpfr(string) ctx=gmpy2.get_context() # Get the results self.ctx=ctx.copy() # Copy the context for later status return fpo
def to_bytes(self, byteorder="big"): self.digits() print(format(self.fpo, "A")) ctx = gmpy2.ieee(self.length * 8) gmpy2.set_context(ctx) b = gmpy2.to_binary(self.fpo) return b
def main(): gmpy2.set_context(gmpy2.context()) gmpy2.get_context().precision = 75 T = int(input()) if T < 1 or T > 100: raise RuntimeError("T is not within the valid range") for i in range(T): n = int(input()) r = Numbers(n) print("Case #" + str(i + 1) + ": " + r)
def recover_msg(N1, N2, N3, C1, C2, C3): m = 42 # your code starts here: to calculate the original message - m # Note 'm' should be an integer N = N1 * N2 * N3 #y1 = N / N1 #y2 = N / N2 #y3 = N / N3 s = [1, 0] r = [(N / N1), N1] i = 2 temp = (N / N1) % N1 while (temp > 0): temp = r[i - 2] % r[i - 1] r.append(temp) s.append(s[i - 2] - (r[i - 2] / r[i - 1]) * s[i - 1]) i += 1 z1 = s[i - 2] s = [1, 0] r = [(N / N2), N2] i = 2 temp = (N / N2) % N2 while (temp > 0): temp = r[i - 2] % r[i - 1] r.append(temp) s.append(s[i - 2] - (r[i - 2] / r[i - 1]) * s[i - 1]) i += 1 z2 = s[i - 2] s = [1, 0] r = [(N / N3), N3] i = 2 temp = (N / N3) % N3 while (temp > 0): temp = r[i - 2] % r[i - 1] r.append(r[i - 2] % r[i - 1]) s.append(s[i - 2] - (r[i - 2] / r[i - 1]) * s[i - 1]) i += 1 z3 = s[i - 2] if z1 < 0: z1 += N1 if z2 < 0: z2 += N2 if z3 < 0: z3 += N3 x = (z1 * C1 * (N / N1) + z2 * C2 * (N / N2) + z3 * C3 * (N / N3)) % N gmpy2.set_context(gmpy2.context()) gmpy2.get_context().precision = 1000000 m = int(gmpy2.cbrt(x)) # your code ends here # convert the int to message string msg = hex(m).rstrip('L')[2:].decode('hex') return msg
def getFinalMaxValue(self, supVal): if not gmpy2.is_finite(supVal): print("Error cannot compute intervals with infinity") exit(-1) bkpCtx = gmpy2.get_context().copy() i = 0 while not gmpy2.is_finite(gmpy2.next_above(supVal)): set_context_precision(self.precision + i, self.exponent + i) i = i + 1 prec = printMPFRExactly(gmpy2.next_above(supVal)) gmpy2.set_context(bkpCtx) return prec
def checkPQDistance(self, keys): if not isinstance(keys, (tuple, list)): keys = [keys] ctx = gmpy2.get_context() ctx.precision = 5000 ctx.round = gmpy2.RoundDown ctx.real_round = gmpy2.RoundDown gmpy2.set_context(ctx) for key in keys: gmpy_key = gmpy2.mpfr(key) skey = int(gmpy2.sqrt(gmpy_key)) skey2 = skey ** 2 if (skey2 > key) or (((skey + 1) ** 2) < key): print skey2 print (skey+1)**2 raise Exception("WTF") bits = int(gmpy2.log2(key - skey2)) if bits < 480: print '%d Has p, q distance of %d bits' % (key, bits)
def checkPQDistance(self, keys): if not isinstance(keys, (tuple, list)): keys = [keys] ctx = gmpy2.get_context() ctx.precision = 5000 ctx.round = gmpy2.RoundDown ctx.real_round = gmpy2.RoundDown gmpy2.set_context(ctx) for key in keys: gmpy_key = gmpy2.mpfr(key) skey = int(gmpy2.sqrt(gmpy_key)) skey2 = skey**2 if (skey2 > key) or (((skey + 1)**2) < key): print skey2 print(skey + 1)**2 raise Exception("WTF") bits = int(gmpy2.log2(key - skey2)) if bits < 480: print '%d Has p, q distance of %d bits' % (key, bits)
def __init__(self, src, ic=None, format=32, round=0): self.ic = ic # Interchange format hex data string self.fpo = None # gnoy2.mpfr object self.format = format # interchange format being created # These values are supplied by the gmpy2.mpfr.digits() method self.digits = None # the binary digits of the signigicand self.dexp = None # the signed exponent self.dprec = None # the precision of the object # These attributes are produced below and are destined for the interchange # format self.isign = None # The value's sign self.ibits = None # The actual bits destined for the significand self.iexp = None # The signed exponent destined for the int if isinstance(src, gmpy2.mpfr): self.fpo = src elif isinstance(src, str): ctx = gmpy2.ieee(format) ctx.round = gmpy2.round = round gmpy2.set_context(ctx) self.fpo = gmpy2.mpfr(src) else: raise ValueError( "%s 'byts' argument unrecognized: %s" % (fp.eloc(self, "__init__", module=this_module), byts) ) self.digits, self.dexp, self.dprec = self.fpo.digits(2) if self.digits[0] == "-": self.isign = 1 self.ibits = self.digits[2:] # Remove the sign and implied first 1 else: self.isign = 0 self.ibits = self.digits[1:] # Remove the implied first 1 # The exponent assumes the leading one is part of the significand, so the # exponent is one larger than is required for the interchange format. self.iexp = self.dexp - 1
def initConstants(cls): from math import sqrt def nextPrime(n=2): while True: for factor in range(2, int(sqrt(n)) + 1): if n % factor == 0: break else: yield n n += 1 # Find the first nRounds primes npgen = nextPrime() primes = [next(npgen) for x in range(cls.nRounds)] fb_mul = 2**cls.wordBits def getFractionalBits(n): return int((n - int(n)) * fb_mul) if cls.use_gmp: from gmpy2 import context, set_context, sqrt, cbrt # context() parameters are platform-dependent! set_context(context(precision=75, round=1)) # OK for gmp 6.1.2 / gmpy 2.1.0 else: cbrt = lambda n: pow(n, 1 / 3) # First wordBits bits of the fractional parts of the square roots of the first 8 primes H = (getFractionalBits(sqrt(n)) for n in primes[:8]) # First wordBits bits of the fractional parts of the cube roots of the first nRounds primes K = (getFractionalBits(cbrt(n)) for n in primes) cls.H_init = tuple(H) cls.K = tuple(K)
when dividing by dx^2, the error grows. Don't kno why the error gets bigger for dx=10e-5. ''' # # On double precision (64) approximation dx=10e-60 gets 0, and dx=10e-20 evaluates the cossine 5 times on the same point. ''' Here, the error gets bigger from dx=10e-20 to dx=10e-60 because they don't have enough digits to register the changes in the step, they evaluate the function different times on same points, then, when dividing by dx^2, the error grows. ''' # # # ''' gmpy2.set_context(gmpy2.context(precision=32)) pi = mp(pi) x = pi/4 func = lambda x: cos(2*pi*60*x) gmpy2.set_context(gmpy2.context(precision=64)) pi = mp(pi) x = pi/4 func = lambda x: cos(2*pi*60*x) %clear
def update(): ctx = gmpy2.get_context() ctx.precision = GSParams.bits gmpy2.set_context(ctx)
import gmpy2 from gmpy2 import mpz __author__ = 'Qubo' N1 = '17976931348623159077293051907890247336179769789423065727343008115' N1 += '77326758055056206869853794492129829595855013875371640157101398586' N1 += '47833778606925583497541085196591615128057575940752635007475935288' N1 += '71082364994994077189561705436114947486504671101510156394068052754' N1 += '0071584560878577663743040086340742855278549092581' gmpy2.set_context(gmpy2.context(precision=2000)) N = mpz(N1) A = gmpy2.ceil(gmpy2.sqrt(N)) SquareA = gmpy2.square(A) if gmpy2.is_square(mpz(gmpy2.sub(SquareA, N))): x = gmpy2.sqrt(gmpy2.sub(SquareA, N)) print 'p = ' + str(mpz(gmpy2.sub(A, x))) print 'q = ' + str(mpz(gmpy2.add(A, x))) else: print 'x is not square, must be wrong...'
# ------------------------------------------------ ### IMPORTS ### from gmpy2 import context, set_context from gmpy2 import mpfr, sqrt, const_pi, exp, sin, cos, polar, norm import matplotlib.pyplot as plt from seaborn import set_style # ------------------------------------------------ ### DEFINITIONS ### set_style('darkgrid') bits = 64 set_context(context(precision=bits, allow_complex=True)) I = sqrt(-1) pi = const_pi(bits) # ------------------------------------------------ ### FUNCTIONS ### def backf(val, digits=8): return [backf(v, digits) for v in val] if isinstance(val, (list, tuple, map, zip)) else float(round(val, digits))
def mp(num): return mpfr(str(num)) def backf(num, digits=5): return float(round(num, digits)) def listf( l ): return list(map(backf, l)) # ------------------------------------------------ ### TESTS ### gmpy2.set_context(gmpy2.context(precision=32)) # for the 1st order Euler EDO method dy_dt = lambda t, y: 4*t - (2/t)*y t_0 = mp(1) y_0 = mp(2) dt = 8*mp(10)**-3 interv = [mp(0.2), mp(1.8)] sol1_t = arange( *interv, dt) sol1_y = list(map(lambda t: t**2 + 1/(t**2), sol1_t)) [apr1_t , apr1_y] = [listf(l) for l in edo1(dy_dt, t_0, y_0, dt, interv)]
# Not passing tests! import decimal Real = decimal.Decimal decimal.getcontext().prec = 80 NUM_EPS = Real("1e-10") NUM_INF = Real(float("inf")) elif NUMBER_TYPE == 'numpy': import numpy Real = numpy.float64 del numpy NUM_EPS = Real("1e-10") NUM_INF = Real(float("inf")) elif NUMBER_TYPE == 'gmpy2': # Not passing tests! import gmpy2 gmpy2.set_context(gmpy2.ieee(128)) Real = gmpy2.mpz NUM_EPS = Real(float("1e-10")) NUM_INF = gmpy2.get_emax_max() del gmpy2 else: raise Exception("Type not found") NUM_EPS_SQ = NUM_EPS * NUM_EPS NUM_ZERO = Real(0.0) NUM_ONE = Real(1.0) class Event: __slots__ = ( "type",
def reset_default_precision(): gmpy2.set_context(gmpy2.context())
import gmpy2 import binascii gmpy2.set_context(gmpy2.get_context()) gmpy2.get_context().precision = 1050 def question1(): N = gmpy2.mpfr( "179769313486231590772930519078902473361797697894230657273430081157732675805505620686985379449212982959585501387537164015710139858647833778606925583497541085196591615128057575940752635007475935288710823649949940771895617054361149474865046711015101563940680527540071584560878577663743040086340742855278549092581", 1050) #print("N",N) A = gmpy2.ceil((gmpy2.sqrt(N))) #print("A:",A) k = gmpy2.square(A) - N #print("K:",k) x = gmpy2.ceil(gmpy2.sqrt(k)) print("x:", x) p = A + x q = A - x if (N == gmpy2.mul(p, q)): if (p > q): p, q = q, p print("found pq:", p, q) def question2(): #25464796146996183438008816563973942229341454268524157846328581927885777969985222835143851073249573454107384461557193173304497244814071505790566593206419759 N = gmpy2.mpfr( "648455842808071669662824265346772278726343720706976263060439070378797308618081116462714015276061417569195587321840254520655424906719892428844841839353281972988531310511738648965962582821502504990264452100885281673303711142296421027840289307657458645233683357077834689715838646088239640236866252211790085787877",
import gmpy2 as g import binascii import sys ctx = g.context(precision=10000000,round=g.RoundUp) g.set_context(ctx) def bruteSmall(N): zero = g.mpz(0) two = g.mpz(2) if g.f_mod(N, two) == zero: return two, g.mpz(g.div(N, two)) i = g.mpz(3) while True: if g.f_mod(N, i) == zero: p = g.mpz(i) q = g.mpz( g.div(N,i) ) if checkFactors(p,q,N) : return p,q i = g.add(i, two) def checkFactors(p,q,N): x = g.f_mod( N, p ) y = g.f_mod( N, q ) zero = g.mpz('0') if g.is_prime(p) and g.is_prime(q): return N == g.mul(p,q) and x == zero and y == zero return False def checkD(e,d,phi):
import gmpy2 import binascii ctx = gmpy2.context(precision=10000000,round=gmpy2.RoundUp) gmpy2.set_context(ctx) def FermatFactor(N): A = gmpy2.mpz( gmpy2.ceil( gmpy2.sqrt(N) ) ) B2 = gmpy2.sub( gmpy2.square(A), N ) while not gmpy2.is_square(B2): A = gmpy2.add( A, gmpy2.mpz("1") ) B2 = gmpy2.sub( gmpy2.square(A), N ) B = gmpy2.sqrt(B2) P = gmpy2.mpz( gmpy2.sub( A, B ) ) Q = gmpy2.mpz( gmpy2.add( A, B ) ) if not checkFactors(P,Q,N): raise Exception("Bad factors generated") return ( P, Q ) def checkFactors(p,q,N): x = gmpy2.f_mod( N, p ) y = gmpy2.f_mod( N, q ) zero = gmpy2.mpz('0') if g.is_prime(p) and g.is_prime(q): return N == g.mul(p,q) and x == zero and y == zero return False def checkD(e,d,phi):
def compute_timings(): # operations = [bf.add, bf.mul, bf.sub, bf.div] operations = [gp.add, gp.mul, gp.sub, gp.div] labels = ["add", "mul", "sub", "div"] for label, operation in zip(labels, operations): precisions, times = [], [] for i in range(3, 45): p = int(1.3**i) precisions.append(p) gp.set_context(gp.context(precision=p)) start = time.time() pi = gp.const_pi() e = gp.exp(1) a = operation(e, pi) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) # pi = bf.const_pi(context) # e = bf.exp(1, context) # a = operation(e, pi, context) end = time.time() times.append(end-start) plt.plot(precisions, times, label=label) plt.legend() plt.xlabel('Precision') plt.ylabel('Time') plt.show()
import builtins import contextlib import inspect import os import gmpy2 gmpy2.set_context(gmpy2.ieee(64)) import soap from soap.context.base import _Context, ConfigError _repr = builtins.repr _str = builtins.str _soap_classes = [c for c in dir(soap) if inspect.isclass(c)] def _run_line_magic(magic, value): from soap.shell import shell with open(os.devnull, 'w') as null: with contextlib.redirect_stdout(null): shell.run_line_magic(magic, value) class SoapContext(_Context): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) for c in _soap_classes: c._repr = c.__repr__ def precision_hook(self, value): fp_format = {'single': 32, 'double': 64}.get(value, None)
import gmpy2 from gmpy2 import mpfr, const_pi, const_euler from numpy import meshgrid, array import matplotlib.pyplot as plt import seaborn as sns import matplotlib.animation as anim import os import cv2 # conda install -c conda-forge opencv=4.1.0 bits = 32 # bits = 64 gmpy2.set_context(gmpy2.context(precision=bits)) # ------------------------------------------------ ### FUNCTIONS ### def mp(num): return mpfr(str(num)) def backf(num, digits=5): return float(round(num, digits)) def listf(l): return list(map(backf, l))