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 __init__(self, input_distribution, input_name, precision, exponent, polynomial_precision=[0, 0]):
"""
Constructor interpolates the density function using Chebyshev interpolation
then uses this interpolation to build a PaCal object:
the self.distribution attribute which contains all the methods we could possibly want
Inputs:
input_distribution: a PaCal object representing the distribution for which we want to compute
the rounding error distribution
precision, exponent: specify the gmpy2 precision environment
polynomial_precision: default precision as implemented in AbstractErrorModel will typically not converge
so it is re-implemented as dynamically setting polynomial_precision. For very low
precision, polynomial_precision needs to be high because the function is very
discontinuous (there are few floating points so it won't impact performance).
For higher precision it needs to be low for performance reason (but it won't impact
accuracy because the function becomes much more regular).
Warning: the relative error is not defined in the interval rounding to 0. In low precision this interval might
have a large probability. This will be reflected by the distribution not integrating to 1.
Example: Uniform(-2,2) with 3 bit exponent, 4 bit mantissa and default polynomial_precision integrates
to 0.926 !
"""
super(LowPrecisionErrorModel, self).__init__(input_distribution, precision, exponent, polynomial_precision)
#self.name = "LPError(" + input_distribution.getName() + ")"
self.name = "LPE_" + input_name
set_context_precision(self.precision, self.exponent)
self.inf_val = mpfr(str(self.input_distribution.range_()[0]))
self.sup_val = mpfr(str(self.input_distribution.range_()[1]))
if not gmpy2.is_finite(self.inf_val):
self.inf_val = gmpy2.next_above(self.inf_val)
if not gmpy2.is_finite(self.sup_val):
self.sup_val = gmpy2.next_below(self.sup_val)
self.max_exp = 2 ** (exponent - 1)
if self.inf_val == 0:
# take most negative exponent
self.exp_inf_val = -self.max_exp
else:
self.exp_inf_val = floor(log(abs(self.inf_val), 2))
if self.sup_val == 0:
# take most negative exponent
self.exp_sup_val = -self.max_exp
else:
self.exp_sup_val = floor(log(abs(self.sup_val), 2))
reset_default_precision()
if polynomial_precision == [0, 0]:
self.polynomial_precision = [floor(400.0 / float(self.precision)), floor(100.0 / float(self.precision))]
def _get_min_exponent(self):
set_context_precision(self.precision, self.exponent)
inf_val = gmpy2.mpfr(str(self.input_distribution.range_()[0]))
self.min_sign = gmpy2.sign(inf_val)
# For some reason the exponent returned by get_exp() is 1 too high and 0 for infinities
if gmpy2.is_finite(inf_val):
e = gmpy2.get_exp(inf_val) - 1
else:
e = 2 ** (self.exponent - 1)
if self.min_sign > 0:
self.min_exp = e
else:
if inf_val < -2 ** (float)(e):
self.min_exp = e + 1
else:
self.min_exp = e
reset_default_precision()
def _get_max_exponent(self):
set_context_precision(self.precision, self.exponent)
sup_val = gmpy2.mpfr(str(self.input_distribution.range_()[1]))
self.max_sign = gmpy2.sign(sup_val)
# For some reason the exponent returned by get_exp() is 1 too high and 0 if sup_val is infinite
if gmpy2.is_finite(sup_val):
e = gmpy2.get_exp(sup_val) - 1
else:
e = 2 ** (self.exponent - 1)
if self.max_sign < 0:
self.max_exp = e
else:
if sup_val > 2 ** float(e):
self.max_exp = e + 1
else:
self.max_exp = e
reset_default_precision()
def __getpdf(self, t):
'''
Constructs the EXACT probability density function at point t in [-1,1]
Exact values are used to build the interpolating polynomial
'''
ctx = gmpy2.get_context()
ctx.precision = self.precision
ctx.emin = self.minexp
ctx.emax = self.maxexp
eps = 2**-self.precision
sums = []
#test if the input is scalar or an array
if np.isscalar(t):
tt = []
tt.append(t)
else:
tt = t
# main loop through all floating point numbers in reduced precision
for ti in tt:
sum = 0.0
# if ti=0 the result is 0 since it definitely covers the whole interval
if float(ti) < 1.0:
x = gmpy2.next_above(gmpy2.inf(-1))
y = gmpy2.next_above(x)
z = gmpy2.next_above(y)
err = float(ti) * eps
# Deal with the very first interval [x,(x+y)/2]
ctx.precision = 53
ctx.emin = -1023
ctx.emax = 1023
xmin = float(x)
xmax = (xmin + float(y)) / 2.0
xp = xmin / (1.0 - err)
if xmin < xp < xmax:
sum += self.inputdistribution.pdf(xp) * abs(xp) * eps / (
1.0 - err)
# Deal with all standard intervals
while gmpy2.is_finite(z):
ctx.precision = 53
ctx.emin = -1023
ctx.emax = 1023
xmin = xmax
xmax = (float(y) + float(z)) / 2.0
xp = float(y) / (1.0 - err)
if xmin < float(xp) < xmax:
sum += self.inputdistribution.pdf(xp) * abs(
xp) * eps / (1.0 - err)
ctx.precision = self.precision
ctx.emin = self.minexp
ctx.emax = self.maxexp
x = y
y = z
z = gmpy2.next_above(z)
# Deal with the very last interval [x,(x+y)/2]
xmin = xmax
xp = float(y) / (1.0 - err)
xmax = float(y)
if xmin < xp < xmax:
sum += self.inputdistribution.pdf(xp) * abs(xp) * eps / (
1.0 - err)
#print('Evaluated at '+repr(ti)+' Result='+repr(sum))
sums.append(sum)
if np.isscalar(t):
return sum
else:
return sums