def interval_sqrt(interval, context_down, context_up):
lower, upper = interval
sqrt_down, sqrt_up = bf.sqrt(lower,
context_down), bf.sqrt(upper, context_up)
out_interval = [sqrt_down, sqrt_up]
derivs = [1 / (2 * sqrt_down), 0], [0, 1 / (2 * sqrt_up)]
return out_interval, derivs
def generate_keys(self,weak):
ok=0
nr=0
print "Generating p"
while ok==0:
self.p=randrange(pow(2,self.bits),pow(2,self.bits+1),2)+1 ##random odd number
ok=self.miller_rabin(self.p,10) ##check primality
nr+=1 ##number of tries
ok=0
print "\t",nr,"tries"
print "Generating q"
nr=0
if 2*self.p>pow(2,self.bits+1): ## p<q<2p
limit=pow(2,self.bits+1)
else:
limit=2*self.p
while ok==0:
self.q=randrange(pow(2,self.bits),limit,2)+1
ok=self.miller_rabin(self.q,10)
nr+=1
print "\t",nr,"tries"
self.n=self.p*self.q
euler=(self.p-1)*(self.q-1)
print "Generating private key"
if (weak==0):
print "\t[Weak mode OFF]"
self.e=65537
x=self.eea(self.e,euler)
self.d=x[0]%euler
else:
print "\t[Weak mode ON]"
ok=0
nr=0
t=long(bigfloat.sqrt(bigfloat.sqrt(self.n))/3)
while ok==0:
self.d=randrange(2,t,2)-1
ok=self.miller_rabin(self.d,10)
nr+=1
print "\t",nr,"tryes"
x=self.eea(self.d,euler)
self.e=x[0]%euler
##print self.e*self.d%euler
##print fractions.gcd(self.e,self.d)
##print self.d<long(bigfloat.sqrt(bigfloat.sqrt(self.n))/3)
print "Done"
def calcRayLengthsAndFarFieldDiff(refRayAngles, cellOffsetToRefRay, sim,
detector):
"""Calculates the distance of a ref ray with given angles (y,z) (towards smaller idxs) to the detector,
the distance of a 2nd ray with a given offset in sim cells (y,z) going to the same point
and the difference between those 2 using the far field approximation
Return tuple (lRefLen, lRayLen, lApproxDiff)
"""
assert (len(refRayAngles) == 2)
assert (len(cellOffsetToRefRay) == 2)
# Convert to meters
rayOffset = cellOffsetToRefRay * sim.cellSize[1:]
dydzRef = np.array([bf.tan(refRayAngles[0]),
bf.tan(refRayAngles[1])]) * detector.distance
lRef = bf.sqrt(detector.distance**2 + dydzRef[0]**2 + dydzRef[1]**2)
dydzRay = dydzRef + rayOffset
lRay = bf.sqrt(detector.distance**2 + dydzRay[0]**2 + dydzRay[1]**2)
# Projection of rayOffset-Vector (with x=0) on lRay
lDiff = np.dot(dydzRay, rayOffset) / lRay
return (lRef, lRay, lDiff)
def main():
start = time.perf_counter()
somme = 0
for i in range(1, 101):
rac = bigfloat.sqrt(i, bigfloat.precision(385))
if rac != int(rac):
s = partie_decimale(rac)[:100]
somme += sumdigits(int(s))
print(somme)
print('temps d execution', time.perf_counter() - start, 'sec')
def calcPhase(particle, detector, sim, waveLen):
"""Calculate the phase the particle has at the detector (current phase assumed to be 0)"""
detCellIdx = getBinnedDetCellIdx(particle, detector, sim)
#print("Target angles:", (detCellIdx - detector.size / 2) * detector.anglePerCell)
dx = detector.distance + (sim.size[0] - particle.pos[0]) * sim.cellSize[0]
dzdy = (detCellIdx - detector.size / 2) * detector.cellSize
dydz = np.flipud(dzdy) + (sim.size[1:] / 2 -
particle.pos[1:]) * sim.cellSize[1:]
distance = bf.sqrt(dx**2 + dydz[0]**2 + dydz[1]**2)
phase = 2 * bf.const_pi() / BigFloat(waveLen) * distance
phase = bf.mod(phase, 2 * bf.const_pi())
return phase
def hasses_bound(self):
''' EC.hasses_bound
this function returns a tuple indicating the interval of Hasse's Theorem
for the curve with a modulus of p:
p + 1 - 2*sqrt(p) <= num points on curve <= p + 1 + 2*sqrt(p)
in order to support finding the bounds for large curves, this function
utilizes the bigfloat libary and returns a bigfloat object.
inputs:
none
returns:
tuple (lowerbound, upperbound)
'''
mod_sqrt = bigfloat.sqrt(self.mod)
lower = self.mod + 1 - (2 * mod_sqrt)
upper = self.mod + 1 + (2 * mod_sqrt)
return (lower, upper)
def checkExtendedFarFieldConstraint(sim, detector, waveLen):
"""Check the errors when the ray is not really going to the top of the detector cell"""
# l2 is the actual ray going to the bottom of the detector cell (furthes away from top)
# l1 is the ref ray going to the top of the cell
# l2_ is the modified l2 to top of cell and l1_ the modified ref ray to the target pt of l2
maxAnglesTop = detector.anglePerCell * detector.size / 2
maxAnglesBottom = maxAnglesTop - detector.anglePerCell
# SimZ = DetX, SimY = DetY
maxAnglesTop = np.flipud(maxAnglesTop)
maxAnglesBottom = np.flipud(maxAnglesBottom)
# This is what we acutally want
(l1, l2_,
l1l2_Diff) = calcRayLengthsAndFarFieldDiff(maxAnglesTop, sim.size[1:] / 2,
sim, detector)
# This is what we easily get
(l1_, l2,
l1_l2Diff) = calcRayLengthsAndFarFieldDiff(maxAnglesBottom,
sim.size[1:] / 2, sim,
detector)
# 1: |(l2_-l1) - (l2-l1_)| <<(!) waveLen
cellError = bf.abs((l2_ - l1) - (l2 - l1_))
print("cellError=", cellError,
"OK" if cellError < 0.05 * waveLen else "ERROR")
# 2: |(l2_-l1) - l1_l2Diff| <<(!) waveLen (Projection used)
projError = bf.abs((l2_ - l1) - l1_l2Diff)
print("projError=", projError,
"OK" if projError < 0.05 * waveLen else "ERROR")
# 3: Try reverse projection: Project onto ref ray as its angles are known
vecRefRay = np.array([bf.tan(maxAnglesTop[0]),
bf.tan(maxAnglesTop[1])]) * detector.distance
lRef = bf.sqrt(detector.distance**2 + vecRefRay[0]**2 + vecRefRay[1]**2)
lReverseProjDiff = np.dot(vecRefRay,
sim.size[1:] / 2 * sim.cellSize[1:]) / lRef
revProjError = bf.abs((l2_ - l1) - lReverseProjDiff)
print("revProjError=", revProjError,
"OK" if revProjError < 0.05 * waveLen else "ERROR")
def test_sqrt_helper(ans, a):
u = bigfloat.Number(ans)
v = bigfloat.Number(a)
self.assertEqual(u, bigfloat.sqrt(v))
def diff(x):
return (calc_y1(x) - (1 - sqrt(1 - (1 - x)**2)))
#!/usr/bin/env python
from bigfloat import sqrt, precision
from pe_tools import is_square
def hundred_digit_sum(n):
s = str(n)
if '.' in s:
i = s.find('.')
s = s[:i] + s[i+1:]
s = s[:100]
return sum(map(int, s))
if __name__ == '__main__':
total = 0
for n in range(1, 100):
if not is_square(n):
s = hundred_digit_sum(sqrt(n, precision(340)))
total += s
print str(total)
def y32(n):
return a1_32 * np.float32((1 + sqrt(5)) / 2)**n - a2_32 * np.float32(
(1 - sqrt(5)) / 2)**n
def y64(n):
return a1_64 * ((1 + sqrt(5)) / 2)**n - a2_64 * ((1 - sqrt(5)) / 2)**n
from env import *
from bigfloat import sqrt, precision
n_max = 50
fib32 = [np.float32(1), np.float32((1 - sqrt(5)) / 2)]
for i in range(0, n_max - 2):
fib32.append(np.float32(fib32[i] + fib32[i + 1]))
fib64 = [np.float64(1), np.float64((1 - sqrt(5)) / 2)]
for i in range(0, n_max - 2):
fib64.append(np.float64(fib64[i] + fib64[i + 1]))
print(fib32)
print(fib64)
plt.figure(figsize=FIG_SIZE_2D, dpi=FIG_DPI_2D)
plt.plot(list(range(n_max)),
np.abs(fib32),
'ro',
color='blue',
label='float32')
plt.plot(list(range(n_max)), np.abs(fib64), 'rx', color='red', label='float64')
plt.yscale('log')
plt.grid(**GRID_OPTIONS)
plt.legend(loc='upper center')
plt.xlabel('n')
plt.ylabel('$\log_{10} |y_n|$')
plt.savefig('./figs/02-fibonacci-c.eps', dpi=SAVE_FIG_DPI)
#plt.show()
def testInterference(self):
cmakeFlags = os.environ["TEST_CMAKE_FLAGS"].split(" ")
paramOverwrites = None
for flag in cmakeFlags:
if flag.startswith("-DPARAM_OVERWRITES:LIST"):
paramOverwrites = flag.split("=", 1)[1].split(";")
params = ParamParser()
if paramOverwrites:
for param in paramOverwrites:
if param.startswith("-D"):
param = param[2:].split("=")
params.AddDefine(param[0], param[1])
params.ParseFolder(os.environ["TEST_OUTPUT_PATH"] +
"/simulation_defines/param")
params.SetCurNamespace("parataxis::detector::PhotonDetector")
detector = scatter.DetectorData(
[],
[params.GetNumber("cellWidth"),
params.GetNumber("cellHeight")], params.GetNumber("distance"))
self.assertEqual(params.GetValue("IncomingParticleHandler"),
"particleHandlers::AddWaveParticles")
params.SetCurNamespace(
"parataxis::particles::scatterer::direction::Fixed")
scatterAngles = [
params.GetNumber("angleY"),
params.GetNumber("angleZ")
]
params.SetCurNamespace("parataxis::initialDensity")
self.assertEqual(params.GetValue("Generator"),
"AvailableGenerators::DoublePoint")
params.SetCurNamespace(
"parataxis::initialDensity::AvailableGenerators::DoublePoint")
scatterParticle1 = scatter.ParticleData([
params.GetNumber("offsetX"),
params.GetNumber("offsetY"),
params.GetNumber("offsetZ1")
], scatterAngles)
scatterParticle2 = scatter.ParticleData([
params.GetNumber("offsetX"),
params.GetNumber("offsetY"),
params.GetNumber("offsetZ2")
], scatterAngles)
params.SetCurNamespace("parataxis")
simulation = scatter.SimulationData(
list(map(int, os.environ["TEST_GRID_SIZE"].split(" "))), [
params.GetNumber("SI::CELL_WIDTH"),
params.GetNumber("SI::CELL_HEIGHT"),
params.GetNumber("SI::CELL_DEPTH")
])
pulseLen = np.floor(
params.GetNumber("laserConfig::PULSE_LENGTH") /
params.GetNumber("SI::DELTA_T"))
self.assertEqual(
params.GetValue("laserConfig::distribution::UsedValue"),
"EqualToPhotons")
numPartsPerTsPerCell = params.GetNumber(
"laserConfig::photonCount::Const::numPhotons")
waveLen = params.GetNumber("wavelengthPhotons",
getFromValueIdentifier=True)
#print("Wavelen=", waveLen)
with open(
os.environ["TEST_BASE_BUILD_PATH"] + "/" +
os.environ["TEST_NAME"] + "_detector.tif", 'rb') as imFile:
im = Image.open(imFile)
detector.resize(im.size)
self.assertTrue(
scatter.checkFarFieldConstraint(simulation, detector, waveLen))
## Calculation
posOnDet1 = scatter.getBinnedDetCellIdx(scatterParticle1, detector,
simulation)
posOnDet2 = scatter.getBinnedDetCellIdx(scatterParticle2, detector,
simulation)
np.testing.assert_allclose(posOnDet1, posOnDet2)
## Checks
imgData = np.array(im)
whitePts = np.transpose(np.where(imgData > 1.e-3))
print(len(whitePts), "white pixels at:", whitePts)
self.assertEqual(len(whitePts), 1)
self.checkCoordinate(whitePts[0], posOnDet1)
phi1 = scatter.calcPhase(scatterParticle1, detector, simulation,
waveLen)
phi2 = scatter.calcPhase(scatterParticle2, detector, simulation,
waveLen)
real = bf.cos(phi1) + bf.cos(phi2)
imag = bf.sin(phi1) + bf.sin(phi2)
sqrtIntensity = bf.sqrt(real * real + imag * imag)
sqrtIntensityPerTs = sqrtIntensity * numPartsPerTsPerCell
#print("Phis:", phi1, phi2, "Diff", phi1-phi2, "SqrtIntensityPerTs", sqrtIntensityPerTs)
expectedDetCellValue = float(bf.sqr(sqrtIntensityPerTs * pulseLen))
np.testing.assert_allclose(imgData[tuple(whitePts[0])],
expectedDetCellValue,
rtol=1e-3)
from bigfloat import sub, add, mul, div, sqr, sqrt, precision a=1e-8 b=10 c=1e-8 p = 100 D = sub(sqr(b) , mul(4, mul(a,c) ), precision(p)) x1 = div( - add(b , sqrt(D, precision(p))) , mul(2,a), precision(p)) x2 = div( - sub(b , sqrt(D, precision(p))) , mul(2,a), precision(p)) print x1,x2
def __calculate_fraction(self):
powered_pi = self.__double_pi_powered_by(self.__d)
return BigFloat.exact('1', precision=110) / bigfloat.sqrt(
(powered_pi * self.__multiply_sigma()))
