def intersection(self, interval):
check_intervals_digits_coincide(self, interval)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundToNearest,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) > mpfr(interval.upper) or mpfr(
self.upper) < mpfr(interval.lower):
return empty_interval
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) > mpfr(interval.upper) or mpfr(
self.upper) < mpfr(interval.lower):
return empty_interval
if mpfr(self.lower) > mpfr(interval.lower):
min_bound = self.lower
else:
min_bound = interval.lower
#min_bound=round_number_down_to_digits(max(mpfr(self.lower), mpfr(interval.lower)), self.digits)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) > mpfr(interval.upper) or mpfr(
self.upper) < mpfr(interval.lower):
return empty_interval
if mpfr(self.upper) < mpfr(interval.upper):
max_bound = self.upper
else:
max_bound = interval.upper
#max_bound=round_number_up_to_digits(min(mpfr(self.upper),mpfr(interval.upper)), self.digits)
return Interval(min_bound, max_bound, True, True, self.digits)
def union(self, interval):
check_intervals_digits_coincide(self, interval)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) < mpfr(interval.lower):
min = self.lower
include_min = self.include_lower
elif mpfr(self.lower) > mpfr(interval.lower):
min = interval.lower
include_min = interval.include_lower
else:
min = interval.lower
include_min = interval.include_lower or self.include_lower
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.upper) < mpfr(interval.upper):
max = interval.upper
include_max = interval.include_upper
elif mpfr(self.upper) > mpfr(interval.upper):
max = self.upper
include_max = self.include_upper
else:
max = self.upper
include_max = self.include_upper or interval.include_upper
return Interval(min, max, include_min, include_max, self.digits)
def adjust_ret_list(retlist):
retlist[0].cdf_low="0.0"
retlist[-1].cdf_up="1.0"
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundUp, precision=mpfr_proxy_precision) as ctx:
min_value=gmpy2.exp10(-digits_for_input_cdf)
current=min_value
for pbox in retlist:
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundDown, precision=mpfr_proxy_precision) as ctx:
if gmpy2.is_zero(gmpy2.mpfr(pbox.cdf_low)) or gmpy2.mpfr(pbox.cdf_low)<current:
pbox.cdf_low=round_number_down_to_digits(current, digits_for_input_cdf)
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundUp, precision=mpfr_proxy_precision) as ctx:
current=current+min_value
if gmpy2.is_zero(gmpy2.mpfr(pbox.cdf_up)) or gmpy2.mpfr(pbox.cdf_up)<current:
pbox.cdf_up=round_number_down_to_digits(current, digits_for_input_cdf)
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundDown, precision=mpfr_proxy_precision) as ctx:
current=gmpy2.sub(gmpy2.mpfr("1.0"), min_value)
for pbox in retlist[::-1]:
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundDown, precision=mpfr_proxy_precision) as ctx:
if gmpy2.mpfr(pbox.cdf_up)==gmpy2.mpfr("1.0") or gmpy2.mpfr(pbox.cdf_up)>current:
pbox.cdf_up=round_number_up_to_digits(current, digits_for_input_cdf)
current=gmpy2.sub(current, min_value)
if gmpy2.mpfr(pbox.cdf_low)==gmpy2.mpfr("1.0") or gmpy2.mpfr(pbox.cdf_low)>current:
pbox.cdf_low=round_number_up_to_digits(current, digits_for_input_cdf)
retlist[0].cdf_low = "0.0"
retlist[-1].cdf_up = "1.0"
return retlist
def subtraction(self, interval):
reset_default_precision()
res_inc_left = False
res_inc_right = False
if self.include_lower and interval.include_lower:
res_inc_left = True
if self.include_upper and interval.include_upper:
res_inc_right = True
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
res_left = gmpy2.sub(mpfr(self.lower), mpfr(interval.upper))
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
res_right = gmpy2.sub(mpfr(self.upper), mpfr(interval.lower))
if res_left <= res_right:
res_right = round_number_up_to_digits(res_right, self.digits)
res_left = round_number_down_to_digits(res_left, self.digits)
return Interval(res_left, res_right, res_inc_left, res_inc_right,
self.digits)
else:
res_right = round_number_down_to_digits(res_right, self.digits)
res_left = round_number_up_to_digits(res_left, self.digits)
return Interval(res_right, res_left, res_inc_right, res_inc_left,
self.digits)
def check_interval_is_zero(interval):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
left = mpfr(interval.lower)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
right = mpfr(interval.upper)
if gmpy2.is_zero(left) and gmpy2.is_zero(right):
return True
return False
def mpfr_roundToIntegral(rm, a):
assert isinstance(a, MPF)
if rm == RM_RNA:
with gmpy2.local_context(mpfr_context(a)):
mpfr_a = mpf_to_mpfr(a)
mpfr_r = gmpy2.rint_round(mpfr_a)
return mpfr_to_mpf(mpfr_r)
else:
check_rm(rm)
with gmpy2.local_context(mpfr_context(a, rm)):
mpfr_a = mpf_to_mpfr(a)
mpfr_r = gmpy2.rint(mpfr_a)
return mpfr_to_mpf(mpfr_r)
def round_value_to_interval(str_value):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
res_left = mpfr(str_value)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
res_right = mpfr(str_value)
return Interval(
round_number_down_to_digits(res_left, digits_for_range),
round_number_up_to_digits(res_right, digits_for_range), True, True,
digits_for_range)
def check_sterbenz_apply(interval1, interval2):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
two_y_left = gmpy2.mul(mpfr("2.0"), mpfr(interval2.lower))
two_x_left = gmpy2.mul(mpfr("2.0"), mpfr(interval1.lower))
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
y_right = mpfr(interval2.upper)
x_right = mpfr(interval1.upper)
if x_right <= two_y_left and y_right <= two_x_left:
return True
return False
def test(self):
with gmpy2.local_context() as ctx1: # sandbox context
ctx1.precision = 4
x = mpfr(1) / 7
with gmpy2.local_context() as ctx2:
# base 10: 0.141
self.assertEqual(x.digits(), ('141', 0, 4))
# base 2: 0.001001
self.assertEqual(x.digits(2), ('1001', -2, 4))
ctx2.precision += 20
# changing context precision does not impact existing values
self.assertEqual(x.digits(2), ('1001', -2, 4))
# returning to distinct context does not impact existing values
self.assertEqual(x.digits(2), ('1001', -2, 4))
return
def compute_middle_point_given_interval(low, upper):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
res_left = gmpy2.add(gmpy2.div(mpfr(upper), mpfr("2.0")),
gmpy2.div(mpfr(low), mpfr("2.0")))
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
res_right = gmpy2.add(gmpy2.div(mpfr(upper), mpfr("2.0")),
gmpy2.div(mpfr(low), mpfr("2.0")))
return Interval(
round_number_down_to_digits(res_left, digits_for_range),
round_number_up_to_digits(res_right, digits_for_range), True, True,
digits_for_range)
def check_zero_is_in_interval(interval):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
left = mpfr(interval.lower)
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
right = mpfr(interval.upper)
if gmpy2.is_zero(left) and interval.include_lower:
return True
if gmpy2.is_zero(right) and interval.include_upper:
return True
if left < mpfr("0.0") < right:
return True
return False
def mpfr_sqrt(rm, a):
assert isinstance(a, MPF)
check_rm(rm)
with gmpy2.local_context(mpfr_context(a, rm)):
mpfr_a = mpf_to_mpfr(a)
mpfr_r = gmpy2.sqrt(mpfr_a)
return mpfr_to_mpf(mpfr_r)
def mpfr_max(a, b):
assert isinstance(a, MPF)
with gmpy2.local_context(mpfr_context(a)):
mpfr_a = mpf_to_mpfr(a)
mpfr_b = mpf_to_mpfr(b)
mpfr_r = gmpy2.max2(mpfr_a, mpfr_b)
return mpfr_to_mpf(mpfr_r)
def compute_uncertainty_given_interval(low, upper):
coefficients = {}
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
res_left = gmpy2.sub(gmpy2.div(mpfr(upper), mpfr("2.0")),
gmpy2.div(mpfr(low), mpfr("2.0")))
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
res_right = gmpy2.sub(gmpy2.div(mpfr(upper), mpfr("2.0")),
gmpy2.div(mpfr(low), mpfr("2.0")))
coefficients[AffineManager.get_new_error_index()]=\
Interval(round_number_down_to_digits(res_left, digits_for_range),
round_number_up_to_digits(res_right, digits_for_range), True, True, digits_for_range)
return coefficients
def mpfr_div(rm, a, b):
assert isinstance(a, MPF)
check_rm(rm)
with gmpy2.local_context(mpfr_context(a, rm)):
mpfr_a = mpf_to_mpfr(a)
mpfr_b = mpf_to_mpfr(b)
mpfr_r = mpfr_a / mpfr_b
return mpfr_to_mpf(mpfr_r)
def mpfr_fma(rm, a, b, c):
assert isinstance(a, MPF)
check_rm(rm)
with gmpy2.local_context(mpfr_context(a, rm)):
mpfr_a = mpf_to_mpfr(a)
mpfr_b = mpf_to_mpfr(b)
mpfr_c = mpf_to_mpfr(c)
mpfr_r = gmpy2.fma(mpfr_a, mpfr_b, mpfr_c)
return mpfr_to_mpf(mpfr_r)
def add_all_coefficients_upper_abs(self):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundAwayZero,
precision=mpfr_proxy_precision) as ctx:
res_right = mpfr("0.0")
for coeff in self.coefficients:
res_right = gmpy2.add(
res_right, abs(mpfr(self.coefficients[coeff].upper)))
# now the number is positive so we can round up
return round_number_up_to_digits(res_right, digits_for_range)
def createDSIfromDistribution(distribution, n=50):
#np.logspace(-9, 5, base=2, num=50) spacing should be done by powers of 2
if distribution.range_()[0]==0.0 and distribution.range_()[-1]==1.0 and use_powers_of_two_spacing:
lin_space = powers_of_two_spacing()
elif "FTE" in distribution.name and use_powers_of_two_spacing:
lin_space = powers_of_two_error(distribution.d.precision)
else:
lin_space = np.linspace(distribution.range_()[0], distribution.range_()[-1], num=n + 1, endpoint=True)
if custom_spacing:
try:
lin_space = distribution.get_my_spacing()
except:
lin_space = np.linspace(distribution.range_()[0], distribution.range_()[-1], num=n + 1, endpoint=True)
cdf_distr=distribution.get_piecewise_cdf()
ret_list=[]
for i in range(0, len(lin_space)-1):
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundDown, precision=mpfr_proxy_precision) as ctx:
lower=round_number_down_to_digits(gmpy2.mpfr(lin_space[i]), digits_for_input_discretization)
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundUp, precision=mpfr_proxy_precision) as ctx:
upper=round_number_up_to_digits(gmpy2.mpfr(lin_space[i+1]), digits_for_input_discretization)
cdf_low_bound=min(1.0, max(0.0, cdf_distr(float(lin_space[i]))))
cdf_up_bound=min(1.0, max(0.0, cdf_distr(float(lin_space[i+1]))))
cdf_low_string=dec2Str(round_near(cdf_low_bound, digits_for_input_cdf))
cdf_up_string=dec2Str(round_near(cdf_up_bound, digits_for_input_cdf))
pbox = PBox(Interval(lower, upper, True, False, digits_for_range),
cdf_low_string, cdf_up_string)
ret_list.append(pbox)
ret_list=adjust_ret_list(ret_list)
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundDown, precision=mpfr_proxy_precision) as ctx:
ret_list[0].interval.lower = \
round_number_down_to_digits(gmpy2.mpfr(distribution.a_real), digits_for_input_discretization)
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundUp, precision=mpfr_proxy_precision) as ctx:
ret_list[-1].interval.upper = \
round_number_up_to_digits(gmpy2.mpfr(distribution.b_real), digits_for_input_discretization)
ret_list[-1].interval.include_upper = True
mixarith=MixedArithmetic(ret_list[0].interval.lower,ret_list[-1].interval.upper,ret_list)
return mixarith
def clean_affine_operation(self):
keys = []
for key in self.coefficients:
value = self.coefficients[key]
remove = [False, False]
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
if gmpy2.is_zero(mpfr(value.lower)):
remove[0] = True
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
if gmpy2.is_zero(mpfr(value.upper)):
remove[1] = True
if remove[0] and remove[1]:
keys.append(key)
for delete in keys:
del self.coefficients[delete]
self.update_interval()
return self
def find_min_abs_interval(interval):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundToZero,
precision=mpfr_proxy_precision) as ctx:
left = abs(mpfr(interval.lower))
right = abs(mpfr(interval.upper))
if left < right:
#Now the number is positive so we can round down
return round_number_down_to_digits(left, digits_for_range)
else:
#Now the number is positive so we can round down
return round_number_down_to_digits(right, digits_for_range)
def compute_interval(self):
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
res_left = gmpy2.sub(mpfr(self.center.lower),
mpfr(self.add_all_coefficients_lower_abs()))
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
res_right = gmpy2.add(mpfr(self.center.upper),
mpfr(self.add_all_coefficients_upper_abs()))
if res_left <= res_right:
return Interval(
round_number_down_to_digits(res_left, digits_for_range),
round_number_up_to_digits(res_right, digits_for_range), True,
True, digits_for_range)
else:
return Interval(
round_number_down_to_digits(res_right, digits_for_range),
round_number_up_to_digits(res_left, digits_for_range), True,
True, digits_for_range)
def check_zero_is_in_interval(self):
zero_is_included = False
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) < mpfr("0.0") < mpfr(self.upper):
zero_is_included = True
if mpfr(self.lower) == mpfr("0.0") and self.include_lower:
zero_is_included = True
if mpfr(self.upper) == mpfr("0.0") and self.include_upper:
zero_is_included = True
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
if mpfr(self.lower) < mpfr("0.0") < mpfr(self.upper):
zero_is_included = True
if mpfr(self.lower) == mpfr("0.0") and self.include_lower:
zero_is_included = True
if mpfr(self.upper) == mpfr("0.0") and self.include_upper:
zero_is_included = True
return zero_is_included
def powers_of_two_spacing():
exp_spacing=[]
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundToNearest, precision=mpfr_proxy_precision) as ctx:
exponent=gmpy2.mpfr("0")
while abs(exponent)<discretization_points:
value=gmpy2.exp2(exponent)
exp_spacing.insert(0, round_number_nearest_to_digits(value, digits_for_input_discretization))
exponent=gmpy2.sub(exponent,gmpy2.mpfr("1"))
exp_spacing.insert(0, "0.0")
for index, value in enumerate(exp_spacing[:-1]):
if value==exp_spacing[index+1]:
print("Problem with digits in powers of 2")
exit(-1)
return exp_spacing
def powers_of_two_error(precision):
exp_spacing=[]
with gmpy2.local_context(gmpy2.context(), round=gmpy2.RoundToNearest, precision=mpfr_proxy_precision) as ctx:
exponent=gmpy2.mpfr(-precision)
counter=0
while counter<discretization_points//2:
value=gmpy2.exp2(exponent)
exp_spacing.insert(0, round_number_nearest_to_digits(value, digits_for_input_discretization))
exponent=gmpy2.sub(exponent,gmpy2.mpfr("1"))
counter=counter+1
exp_spacing_reverse=copy.deepcopy(exp_spacing)
exp_spacing_reverse.reverse()
exp_spacing_reverse=["-"+s for s in exp_spacing_reverse]
exp_spacing=exp_spacing_reverse+["0.0"]+exp_spacing
for index, value in enumerate(exp_spacing[:-1]):
if value==exp_spacing[index+1]:
print("Problem with digits in powers of 2")
exit(-1)
return exp_spacing
def multiplication(self, interval):
reset_default_precision()
tmp_res_left = []
tmp_res_right = []
zero_is_included = self.check_zero_is_in_interval(
) or interval.check_zero_is_in_interval()
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
tmp_res_left.append(
gmpy2.mul(mpfr(self.lower), mpfr(interval.lower)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.lower), mpfr(interval.upper)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.upper), mpfr(interval.lower)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.upper), mpfr(interval.upper)))
min_index = [
i for i, value in enumerate(tmp_res_left)
if value == min(tmp_res_left)
]
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
tmp_res_right.append(
gmpy2.mul(mpfr(self.lower), mpfr(interval.lower)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.lower), mpfr(interval.upper)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.upper), mpfr(interval.lower)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.upper), mpfr(interval.upper)))
max_index = [
i for i, value in enumerate(tmp_res_right)
if value == max(tmp_res_right)
]
tmp_bounds = [
self.include_lower * interval.include_lower,
self.include_lower * interval.include_upper,
self.include_upper * interval.include_lower,
self.include_upper * interval.include_upper
]
res_inc_left = any([tmp_bounds[index] for index in min_index])
res_inc_right = any([tmp_bounds[index] for index in max_index])
min_value = tmp_res_left[min_index[0]]
max_value = tmp_res_right[max_index[0]]
if gmpy2.is_zero(min_value) and zero_is_included:
res_inc_left = True
if gmpy2.is_zero(max_value) and zero_is_included:
res_inc_right = True
res_left = round_number_down_to_digits(min_value, self.digits)
res_right = round_number_up_to_digits(max_value, self.digits)
return Interval(res_left, res_right, res_inc_left, res_inc_right,
self.digits)
cipher = 2780321436921227845269766067805604547641764672251687438825498122989499386967784164108893743279610287605669769995594639683212592165536863280639528420328182048065518360606262307313806591343147104009274770408926901136562839153074067955850912830877064811031354484452546219065027914838811744269912371819665118277221
n = 23571113171923293137414347535961677173798389971011031071091131271311371391491511571631671731791811911931971992112232272292332392412512572632692712772812832933073113133173313373473493533593673733793833893974014094194214314334394434494574614634674794874914995035095215235415475575635695715775875935996016076136176196316416436476536596616736776836917017097197277337397437517577617697737877978098118218238278298398538578598638778818838879079119199299379419479539679719779839919971009101310191431936117404941729571877755575331917062752829306305198341421305376800954281557410379953262534149212590443063350628712530148541217933209759909975139820841212346188350112608680453894647472456216566674289561525527394398888860917887112180144144965154878409149321280697460295807024856510864232914981820173542223592901476958693572703687098161888680486757805443187028074386001621827485207065876653623459779938558845775617779542038109532989486603799040658192890612331485359615639748042902366550066934348195272617921683
Low Public Exponent Attack
"""
import sys
try:
import gmpy2
except ImportError:
print("Install gmpy2 first to run this program")
sys.exit()
e = 3
cipher = 2780321436921227845269766067805604547641764672251687438825498122989499386967784164108893743279610287605669769995594639683212592165536863280639528420328182048065518360606262307313806591343147104009274770408926901136562839153074067955850912830877064811031354484452546219065027914838811744269912371819665118277221
n = 23571113171923293137414347535961677173798389971011031071091131271311371391491511571631671731791811911931971992112232272292332392412512572632692712772812832933073113133173313373473493533593673733793833893974014094194214314334394434494574614634674794874914995035095215235415475575635695715775875935996016076136176196316416436476536596616736776836917017097197277337397437517577617697737877978098118218238278298398538578598638778818838879079119199299379419479539679719779839919971009101310191431936117404941729571877755575331917062752829306305198341421305376800954281557410379953262534149212590443063350628712530148541217933209759909975139820841212346188350112608680453894647472456216566674289561525527394398888860917887112180144144965154878409149321280697460295807024856510864232914981820173542223592901476958693572703687098161888680486757805443187028074386001621827485207065876653623459779938558845775617779542038109532989486603799040658192890612331485359615639748042902366550066934348195272617921683
n = hex(n)
import gmpy2
with gmpy2.local_context(gmpy2.context(), precision=800) as ctx:
ctx.precision += 800
root = gmpy2.cbrt(cipher)
try:
print(str('%x' % +int(root)).decode('hex'))
except AttributeError:
print(bytes.fromhex(str('%x' % +int(root))).decode('utf-8'))
# answer!!
# dsc{t0-m355-w1th-m4th-t4k35-4-l0t-0f-sp1n3}
out = partial(print, sep='\n', end='\n\n')
if __name__ == '__main__':
# Reales de precisión arbitraria
# En el siguiente ejemplo se muestra con la precisión normal
out ('Raíz de dos: ', gmpy2.sqrt(2))
# Obtenemos la precisión máxima teórica de la computadora
out ('Precisión máxima: ', gmpy2.get_max_precision())
# ¿Cuál es la precisión por defecto?
out ('Precisión por defecto', gmpy2.get_context().precision)
# Cambiamos la precisión de la biblioteca
gmpy2.get_context().precision=100
# Otra vez la raíz de dos, con precisión aumentada
out ('Raíz de dos: ', gmpy2.sqrt(2))
# De hecho es la precisión de cualquier número
out ('Un flotante: ', mpfr('1.2'))
# Ahora creamos un contexto para manejar la precisión
with gmpy2.local_context(gmpy2.context(), precision=200) as ctx:
out ('Precisión alterada en contexto', gmpy2.sqrt(2))
ctx.precision += 100
out ('Aún mejor precision', gmpy2.sqrt(2))
# De regreso al contexto original, precision normal
out ('Raíz de dos', gmpy2.sqrt(2))
def wrapped(self: 'FPVector', *args, **kwargs):
with gmpy2.local_context(self._ctx_):
return fn(self, *args, **kwargs)
def division(self, interval):
reset_default_precision()
tmp_res_left = []
tmp_res_right = []
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundDown,
precision=mpfr_proxy_precision) as ctx:
new_right_lower = gmpy2.div(1.0, mpfr(interval.upper))
new_right_upper = gmpy2.div(1.0, mpfr(interval.lower))
tmp_res_left.append(
gmpy2.mul(mpfr(self.lower), mpfr(new_right_lower)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.lower), mpfr(new_right_upper)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.upper), mpfr(new_right_lower)))
tmp_res_left.append(
gmpy2.mul(mpfr(self.upper), mpfr(new_right_upper)))
min_index = [
i for i, value in enumerate(tmp_res_left)
if value == min(tmp_res_left)
]
with gmpy2.local_context(gmpy2.context(),
round=gmpy2.RoundUp,
precision=mpfr_proxy_precision) as ctx:
new_right_lower = gmpy2.div(1.0, mpfr(interval.upper))
new_right_upper = gmpy2.div(1.0, mpfr(interval.lower))
tmp_res_right.append(
gmpy2.mul(mpfr(self.lower), mpfr(new_right_lower)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.lower), mpfr(new_right_upper)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.upper), mpfr(new_right_lower)))
tmp_res_right.append(
gmpy2.mul(mpfr(self.upper), mpfr(new_right_upper)))
max_index = [
i for i, value in enumerate(tmp_res_right)
if value == max(tmp_res_right)
]
# We have to swap the boundaries here 1/[1,2]=[.5, 1]
new_right_lower_inc = interval.include_upper
new_right_upper_inc = interval.include_lower
tmp_bounds = [
self.include_lower * new_right_lower_inc,
self.include_lower * new_right_upper_inc,
self.include_upper * new_right_lower_inc,
self.include_upper * new_right_upper_inc
]
res_inc_left = any([tmp_bounds[index] for index in min_index])
res_inc_right = any([tmp_bounds[index] for index in max_index])
res_left = round_number_down_to_digits(tmp_res_left[min_index[0]],
self.digits)
res_right = round_number_up_to_digits(tmp_res_right[max_index[0]],
self.digits)
return Interval(res_left, res_right, res_inc_left, res_inc_right,
self.digits)
def mpfr_neg(a):
assert isinstance(a, MPF)
with gmpy2.local_context(mpfr_context(a)):
mpfr_a = mpf_to_mpfr(a)
mpfr_r = -mpfr_a
return mpfr_to_mpf(mpfr_r)
