def PI(maxK=70,
prec=1008,
disp=1007,
K=6,
M=1,
L=13591409,
X=1,
S=13591409,
ki=1):
gc().prec = prec
'''
state = getState(maxK, prec, disp)
if state != None:
K,M,L,X,S,ki = int(state['K']),int(state['M']),int(state['L']),int(state['X']),Dec(state['S']),int(state['k'])
'''
for k in range(ki, maxK + 1):
M = (K**3 - 16 * K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
#saveState(K,M,L,X,S,k,maxK,prec,disp)
print(f'k:{k}', flush=True)
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp])
print("PI(maxK={} iterations, gc().prec={}, disp={} digits) =\n{}".format(
maxK, prec, disp, pi))
return pi
def chudnovsky(precision, max_iter=100, timeout=False):
"""
Calculates pi using the Chudnovsky algorithm:
https://en.wikipedia.org/wiki/Chudnovsky_algorithm
Runs in O(n log(n)^3).
:param precision: The level of precision to be used
:param max_iter: The maximum number of iterations to be used
:param timeout: The maximum number of seconds to pass before refusing to continue summation.
Note that this can potentially drastically affect the accuracy of the calculation.
:return: Pi to some level of precision
"""
gc().prec = precision + 1
k_term = 6
multinomial_term = 1
linear_term = 13591409
exponential_term = 1
current_sum = 13591409
start = time.time()
for k in range(1, max_iter + 1):
if timeout and time.time() > start + timeout:
break
multinomial_term = (k_term**3 - 16 * k_term) * multinomial_term // k**3
linear_term += 545140134
exponential_term *= -262537412640768000
current_sum += Dec(multinomial_term * linear_term) / exponential_term
k_term += 12
c_term = 426880 * Dec(10005).sqrt()
pi = c_term / current_sum
pi = Dec(str(pi)[:precision]) # Only return up to the level of precision
return pi
def Chudnovsky(n):
gc().prec = n
if n > 1000:
raise Exception(
f"User entered [{n}]: out of bounds exception.\nValue must be <=1000."
)
#initialize
_sum = 0
C = Dec(426880) * Dec(10005).sqrt()
M, L, X = Dec(1), Dec(13591409), Dec(1)
_sum += Dec(M * L) / Dec(X)
#The number of iterations: the chudnovsky algorithm calculates ~14 decimal places per iteration
#so to cut excess iterations we look at the number of desired decimal places
k = n // 14
#produce next summation terms
for i in range(0, k):
L += Dec(545140134)
X *= Dec(-262537412640768000)
M *= Dec((12 * i + 2) * (12 * i + 6) * (12 * i + 10) / ((i + 1)**3))
_sum += Dec(M * L) / Dec(X)
ans = C / _sum
#determine error
err = Dec(ans - pi)
return [ans, err]
def e_Calculator():
print("'e' (Euler's number) Calculator")
digits = int(
input('Enter the number of digits you want for your value of e : '))
steps = int(
input(
'Enter the maximum number of steps desired (if unsure, enter 500) : '
))
prec = 3 * digits
gc().prec = prec
maxSteps = steps # You should stop when k! > 10^n
# See Gourdon & Sebah (2001) Mathematical constants and computation, Jan 11
s = 1
for k in range(1, maxSteps + 1):
numerator = 1
denominator = factorial(k)
s += Dec(1) / factorial(
k
) # Note, if you do Dec(1/factorial(k)), your answer will diverge after the 16th decimal place
e = s
e = Dec(str(e)[:digits + 1]) # Drop few digits of precision for accuracy
print(f'Your value for e = {e}')
print(
'\nThe value obtained should not diverge from http://www.numberworld.org/digits/E/ or other reference value.'
)
print('But if it does, then you must increase the number of steps.')
print(
'However, increasing the number of digits or steps comes at the cost of processor power.'
)
def calculate_e(precision, max_iter=100, timeout=False):
"""
Calculates e using an algorithm found here:
https://en.wikipedia.org/wiki/List_of_representations_of_e
Accurate to within 2 * 10^-12 after 5 iterations.
:param precision: The level of precision to be used
:param max_iter: The maximum number of iterations to be used
:param timeout: The maximum number of seconds to pass before refusing to continue summation.
Note that this can potentially drastically affect the accuracy of the calculation.
:return: Euler's number e to some level of precision
"""
gc().prec = precision + 1
current_sum = Dec(0)
start = time.time()
for k in range(0, max_iter + 1):
if timeout and time.time() > start + timeout:
break
numerator = Dec((4 * k) + 3)
denominator_left = Dec(2**((2 * k) + 1))
denominator_right = factorial(Dec(2 * k + 1))
current_term = Dec(numerator / (denominator_left * denominator_right))
current_sum += current_term
e = Dec(current_sum)**2
e = Dec(str(e)[:precision]) # Only return up to the level of precision
return e
def machin_for():
arc_tan_1_239 = arc_tan(1 / 239, 3)
arc_tan_1_5 = arc_tan(1 / 5, 3)
filename = os.path.abspath('../y-cruncher/10K/pi-dec-chudnovsky.txt')
f = open(filename, "r")
ref = f.read()
number = 0
for i in range(3, gc().prec):
arc_tan_1_239 += arc_tan_it(1 / 239, i)
arc_tan_1_5 += arc_tan_it(1 / 5, i)
pi = 4 * (4 * arc_tan_1_5 - arc_tan_1_239)
if (i % ((gc().prec) // 100) == 0):
print('\n')
print(str(pi)[:number])
print(i)
number = check(str(pi), ref, number, gc().prec)
print(number)
print(str(pi)[:number])
def PI(maxK=70, prec=1008, disp=1007): # parameter defaults chosen to gain 1000+ digits within a few seconds
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxK+1):
M = (K**3 - (K<<4)) * M / k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp]) # drop few digits of precision for accuracy
print("PI(maxK=%d iterations, gc().prec=%d, disp=%d digits) =\n%s" % (maxK, prec, disp, pi))
return pi
def PI(maxK: int = 70, prec: int = 1008, disp: int = 1007): # Parameter defaults chosen to gain 1000+ digits within a few seconds
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
start = time.time()
for k in range(1, maxK + 1):
M = (K**3 - 16*K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp]) # Drop few digits of precision for accuracy
number=compare(str(pi),disp)
end = time.time()
elapsed = end - start
print("PI(maxK={} iterations, gc().prec={}, disp={} digits) =\n{}\n\ntime: {}\n\nnumber: {}".format(maxK, prec, disp, pi, elapsed, number))
return pi
def PI(
maxK=317,
prec=15001,
disp=15000
): # Parameter defaults chosen to gain 1000+ digits within a few seconds
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxK + 1):
M = (K**3 - 16 * K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp]) # Drop few digits of precision for accuracy
#print("PI(maxK={} iterations, gc().prec={}, disp={} digits) =\n{}".format(maxK, prec, disp, pi))
return pi
def PI(
maxK=70,
prec=1008,
disp=1007
): # parameter defaults chosen to gain 1000+ digits within a few seconds
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxK + 1):
M = (K**3 - 16 * K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp]) # drop few digits of precision for accuracy
print("PI(maxK=%d iterations, gc().prec=%d, disp=%d digits) =\n%s" %
(maxK, prec, disp, pi))
return pi
def pi(maxK=70, prec=1008, disp=1007):
"""
maxK: nuber of iterations
prec: precision of decimal places
disp: number of decimal places shown
"""
from decimal import Decimal as Dec, getcontext as gc
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxK + 1):
M = Dec((K**3 - (K << 4)) * M / k**3)
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp])
return pi
def pi(maxK=70, prec=1008, disp=1007):
"""
maxK: nuber of iterations
prec: precision of decimal places
disp: number of decimal places shown
"""
from decimal import Decimal as Dec, getcontext as gc
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxK+1):
M = Dec((K**3 - (K<<4)) * M / k**3)
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp])
return pi
def pi_to_n(digits):
X, M, K, L, S = 1, 1, 6, 13591409, 13591409
C = Decimal(426880 * math.sqrt(10005))
gc().prec = 1000
for k in range(1, 70):
M += M * (K**3 - 16 * K) / k**3
K += 12
X *= -262537412640768000
L += 545140134
S += Decimal(M * L) / X
pi = C / S
pi = Decimal(str(pi)[:digits + 2])
print(pi)
return pi
def calcChud(
maxIter=70,
prec=1003,
disp=1002
): # parameter defaults chosen to gain 1000 digits after the comma
gc().prec = prec
K, M, L, X, S = 6, 1, 13591409, 1, 13591409
for k in range(1, maxIter + 1):
M = (K**3 - 16 * K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:disp]) # drop few digits of precision for accuracy
print(
"PI(maxIter={} iterations, gc().prec={}, disp={} digits) =\n{}".format(
maxIter, prec, disp, pi))
return pi
def PI2(K):
global teclado
global final
p = 0
gc().prec = 156
start_time = time.time()
contador = 0
iteracion = 0
for n in range(0, K + 1):
while (teclado == True):
if contador == 0:
print("Pausado")
contador = 1
else:
contador = 1
#print("\n")
A = (-1)**n
B = factorial(6 * n)
C = (545140134 * n + 13591409)
D = (factorial(3 * n))
E = (factorial(n)**3)
F = Dec((640320))**Dec((3 * n + (3 / 2)))
p = (((A * B * C) / (D * E * F)) + p)
iteracion = 1 + iteracion
porcentaje = (iteracion / K) * 100
print(porcentaje)
pi = 1 / (12 * p)
pi = str(pi)[:154]
guardar(pi)
por = similar(
pi,
"3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848"
)
print(
"\nPID: %s, similitud con pi %s, Thread Name: %s, \nValor de pi: %s " %
(os.getpid(), por, threading.current_thread().name, pi))
final = final + 1
end_time = time.time()
print("El tiempo del thread =", end_time - start_time)
return
def nthOfPI(
iteration=70,
precision=110,
display=100
): # parameter defaults chosen to gain 100 digits within a short time
gc().prec = precision
K, M, L, X, S = 6, 1, 13591409, 1, 13591409 #the values defined here are part of constants of Chudnovsky Algorithm
for k in range(1, iteration + 1): #Algorithm Implemented
M = (K**3 - 16 * K) * M // k**3
L += 545140134
X *= -262537412640768000
S += Dec(M * L) / X
K += 12
pi = 426880 * Dec(10005).sqrt() / S
pi = Dec(str(pi)[:display]) # drop few digits of precision for accuracy
print(
"PI(Loop={} iterations, context precision={}, display={} digits) =\n{}"
.format(iteration, precision, display, pi))
return pi
import matplotlib.pyplot as plt
import numpy as np
### System Subroutine ###
clear = lambda: os.system('cls')
unicode_cmd = lambda: os.system('chcp 65001 &')
### System Variable Settings ###
"""
_V -> V; _Q -> Q; oVFE -> V'; _Q2 -> Q'; _tFE -> tFE; _EC -> EC; _Pr -> Pr
math.pow(10,4) -> 10X10X10X10
math.sqrt(4) -> √4
2*3 - > 2X3
"""
cfg_parameter = cfg.Config().get('parameter')
gc().prec = int(cfg_parameter['f_len']) # set float precision
_tFE = eval(cfg_parameter['tfe'])
_Ec = eval(cfg_parameter['ec'])
_Pr = eval(cfg_parameter['pr'])
cfg_file = cfg.Config().get('file') # set float precision
dirsrcpath = cfg_file['src']
if cfg_file['src'] is '':
dirsrcpath = cfg.Config().path + 'src' + '\\'
dirdstpath = cfg_file['dst']
if cfg_file['dst'] is '':
dirdstpath = cfg.Config().path + 'dst' + '\\'
if not os.path.exists(dirdstpath):
os.makedirs('dst')
ofilename = cfg_file['src_f_org'] # orignal filename
mfilename = cfg_file['src_f_map'] # map v-i filename
#!/usr/bin/env python -i
# Calculating radical form expression for cos(2^n * pi / 257)
from math import *
from decimal import Decimal as Dec, getcontext as gc
gc().prec = 30
s = lambda r: Dec(r).sqrt()
Q = lambda b, c: ((b + s(b * b - 4 * c)) / 2, (b - s(b * b - 4 * c)) / 2)
t0, t1 = Q(-1, -64)
t = [t0, t1]
(z0, z2), (z1, z3) = Q(t0, -16), Q(t1, -16)
z = [z0, z1, z2, z3]
Y = lambda z, t: Q(z, -5 - t - 2 * z)
(y0, y4), (y5, y1), (y2, y6), (y7, y3) = (Y(z0, t0), Y(z1,
t1), Y(z2,
t0), Y(z3, t1))
y = [y0, y1, y2, y3, y4, y5, y6, y7]
X = lambda n: Q(y[n], t[n & 1] + y[n] + y[(n + 2) & 7] + 2 * y[(n + 5) & 7])
(x0, x8), (x1, x9), (x2, x10), (x3, x11), (x4,
x12), (x5,
x13), (x14,
x6), (x7, x15) = map(
X, range(8))
x = [x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]
V = lambda n: Q(x[n], x[n] + x[(n + 1) & 15] + x[(n + 2) & 15] + x[
from decimal import Decimal as de
from decimal import getcontext as gc
gc().prec = 50
f = 1
e = de(2)
for i in range(2, 50):
f *= i
e += de(1)/de(f)
# print(f)
print(e)
# Voir http://serge.mehl.free.fr/anx/pi_machin.html
import math
import time
import os
from decimal import Decimal as Dec, getcontext as gc
gc().prec = 100000
def arc_tan_it(x, n):
'''
Arctan nème terme
'''
numerator = math.pow(-1, n) * math.pow(x, 2 * n + 1)
denominator = 2 * n + 1
return Dec(numerator) / Dec(denominator)
def arc_tan(x, iterations):
'''
Arctan à l'ordre 'iterations' de 'x'
'''
arc_tan_of_x = Dec(0)
for n in range(0, iterations):
arc_tan_of_x += arc_tan_it(x, n)
return arc_tan_of_x
def check(calculated, ref, number, prec):
test = True
