def generate_approx_poly_near_zero(self, function, high_bound, error_bound,
variable):
""" Generate polynomial approximation scheme """
error_function = lambda p, f, ai, mod, t: sollya.dirtyinfnorm(
p - f, ai)
# Some issues encountered when 0 is one of the interval bound
# so we use a symetric interval around it
approx_interval = Interval(2**-100, high_bound)
local_function = function / sollya.x
degree = sollya.sup(
sollya.guessdegree(local_function, approx_interval, error_bound))
degree_list = range(0, int(degree) + 4, 2)
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
function / sollya.x,
degree_list, [1] + [self.precision] * (len(degree_list) - 1),
approx_interval,
sollya.absolute,
error_function=error_function)
Log.report(
Log.Info, "approximation poly: {}\n with error {}".format(
poly_object, approx_error))
poly_scheme = Multiplication(
variable,
PolynomialSchemeEvaluator.generate_horner_scheme(
poly_object, variable, self.precision))
return poly_scheme, approx_error
def generate_scheme(self):
# declaring target and instantiating optimization engine
vx = self.implementation.add_input_variable("x", self.precision)
Log.set_dump_stdout(True)
Log.report(Log.Info,
"\033[33;1m generating implementation scheme \033[0m")
if self.debug_flag:
Log.report(Log.Info, "\033[31;1m debug has been enabled \033[0;m")
# local overloading of RaiseReturn operation
def ExpRaiseReturn(*args, **kwords):
kwords["arg_value"] = vx
kwords["function_name"] = self.function_name
if self.libm_compliant:
return RaiseReturn(*args, precision=self.precision, **kwords)
else:
return Return(kwords["return_value"], precision=self.precision)
test_nan_or_inf = Test(vx,
specifier=Test.IsInfOrNaN,
likely=False,
debug=debug_multi,
tag="nan_or_inf")
test_nan = Test(vx,
specifier=Test.IsNaN,
debug=debug_multi,
tag="is_nan_test")
test_positive = Comparison(vx,
0,
specifier=Comparison.GreaterOrEqual,
debug=debug_multi,
tag="inf_sign")
test_signaling_nan = Test(vx,
specifier=Test.IsSignalingNaN,
debug=debug_multi,
tag="is_signaling_nan")
return_snan = Statement(
ExpRaiseReturn(ML_FPE_Invalid,
return_value=FP_QNaN(self.precision)))
# return in case of infinity input
infty_return = Statement(
ConditionBlock(
test_positive,
Return(FP_PlusInfty(self.precision), precision=self.precision),
Return(FP_PlusZero(self.precision), precision=self.precision)))
# return in case of specific value input (NaN or inf)
specific_return = ConditionBlock(
test_nan,
ConditionBlock(
test_signaling_nan, return_snan,
Return(FP_QNaN(self.precision), precision=self.precision)),
infty_return)
# return in case of standard (non-special) input
# exclusion of early overflow and underflow cases
precision_emax = self.precision.get_emax()
precision_max_value = S2 * S2**precision_emax
exp_overflow_bound = sollya.ceil(log(precision_max_value))
early_overflow_test = Comparison(vx,
exp_overflow_bound,
likely=False,
specifier=Comparison.Greater)
early_overflow_return = Statement(
ClearException() if self.libm_compliant else Statement(),
ExpRaiseReturn(ML_FPE_Inexact,
ML_FPE_Overflow,
return_value=FP_PlusInfty(self.precision)))
precision_emin = self.precision.get_emin_subnormal()
precision_min_value = S2**precision_emin
exp_underflow_bound = floor(log(precision_min_value))
early_underflow_test = Comparison(vx,
exp_underflow_bound,
likely=False,
specifier=Comparison.Less)
early_underflow_return = Statement(
ClearException() if self.libm_compliant else Statement(),
ExpRaiseReturn(ML_FPE_Inexact,
ML_FPE_Underflow,
return_value=FP_PlusZero(self.precision)))
# constant computation
invlog2 = self.precision.round_sollya_object(1 / log(2), sollya.RN)
interval_vx = Interval(exp_underflow_bound, exp_overflow_bound)
interval_fk = interval_vx * invlog2
interval_k = Interval(floor(inf(interval_fk)),
sollya.ceil(sup(interval_fk)))
log2_hi_precision = self.precision.get_field_size() - (
sollya.ceil(log2(sup(abs(interval_k)))) + 2)
Log.report(Log.Info, "log2_hi_precision: %d" % log2_hi_precision)
invlog2_cst = Constant(invlog2, precision=self.precision)
log2_hi = round(log(2), log2_hi_precision, sollya.RN)
log2_lo = self.precision.round_sollya_object(
log(2) - log2_hi, sollya.RN)
# argument reduction
unround_k = vx * invlog2
unround_k.set_attributes(tag="unround_k", debug=debug_multi)
k = NearestInteger(unround_k,
precision=self.precision,
debug=debug_multi)
ik = NearestInteger(unround_k,
precision=self.precision.get_integer_format(),
debug=debug_multi,
tag="ik")
ik.set_tag("ik")
k.set_tag("k")
exact_pre_mul = (k * log2_hi)
exact_pre_mul.set_attributes(exact=True)
exact_hi_part = vx - exact_pre_mul
exact_hi_part.set_attributes(exact=True,
tag="exact_hi",
debug=debug_multi,
prevent_optimization=True)
exact_lo_part = -k * log2_lo
exact_lo_part.set_attributes(tag="exact_lo",
debug=debug_multi,
prevent_optimization=True)
r = exact_hi_part + exact_lo_part
r.set_tag("r")
r.set_attributes(debug=debug_multi)
approx_interval = Interval(-log(2) / 2, log(2) / 2)
approx_interval_half = approx_interval / 2
approx_interval_split = [
Interval(-log(2) / 2, inf(approx_interval_half)),
approx_interval_half,
Interval(sup(approx_interval_half),
log(2) / 2)
]
# TODO: should be computed automatically
exact_hi_interval = approx_interval
exact_lo_interval = -interval_k * log2_lo
opt_r = self.optimise_scheme(r, copy={})
tag_map = {}
self.opt_engine.register_nodes_by_tag(opt_r, tag_map)
cg_eval_error_copy_map = {
vx:
Variable("x", precision=self.precision, interval=interval_vx),
tag_map["k"]:
Variable("k", interval=interval_k, precision=self.precision)
}
#try:
if is_gappa_installed():
eval_error = self.gappa_engine.get_eval_error_v2(
self.opt_engine,
opt_r,
cg_eval_error_copy_map,
gappa_filename="red_arg.g")
else:
eval_error = 0.0
Log.report(Log.Warning,
"gappa is not installed in this environnement")
Log.report(Log.Info, "eval error: %s" % eval_error)
local_ulp = sup(ulp(sollya.exp(approx_interval), self.precision))
# FIXME refactor error_goal from accuracy
Log.report(Log.Info, "accuracy: %s" % self.accuracy)
if isinstance(self.accuracy, ML_Faithful):
error_goal = local_ulp
elif isinstance(self.accuracy, ML_CorrectlyRounded):
error_goal = S2**-1 * local_ulp
elif isinstance(self.accuracy, ML_DegradedAccuracyAbsolute):
error_goal = self.accuracy.goal
elif isinstance(self.accuracy, ML_DegradedAccuracyRelative):
error_goal = self.accuracy.goal
else:
Log.report(Log.Error, "unknown accuracy: %s" % self.accuracy)
# error_goal = local_ulp #S2**-(self.precision.get_field_size()+1)
error_goal_approx = S2**-1 * error_goal
Log.report(Log.Info,
"\033[33;1m building mathematical polynomial \033[0m\n")
poly_degree = max(
sup(
guessdegree(
expm1(sollya.x) / sollya.x, approx_interval,
error_goal_approx)) - 1, 2)
init_poly_degree = poly_degree
error_function = lambda p, f, ai, mod, t: dirtyinfnorm(f - p, ai)
polynomial_scheme_builder = PolynomialSchemeEvaluator.generate_estrin_scheme
#polynomial_scheme_builder = PolynomialSchemeEvaluator.generate_horner_scheme
while 1:
Log.report(Log.Info, "attempting poly degree: %d" % poly_degree)
precision_list = [1] + [self.precision] * (poly_degree)
poly_object, poly_approx_error = Polynomial.build_from_approximation_with_error(
expm1(sollya.x),
poly_degree,
precision_list,
approx_interval,
sollya.absolute,
error_function=error_function)
Log.report(Log.Info, "polynomial: %s " % poly_object)
sub_poly = poly_object.sub_poly(start_index=2)
Log.report(Log.Info, "polynomial: %s " % sub_poly)
Log.report(Log.Info, "poly approx error: %s" % poly_approx_error)
Log.report(
Log.Info,
"\033[33;1m generating polynomial evaluation scheme \033[0m")
pre_poly = polynomial_scheme_builder(
poly_object, r, unified_precision=self.precision)
pre_poly.set_attributes(tag="pre_poly", debug=debug_multi)
pre_sub_poly = polynomial_scheme_builder(
sub_poly, r, unified_precision=self.precision)
pre_sub_poly.set_attributes(tag="pre_sub_poly", debug=debug_multi)
poly = 1 + (exact_hi_part + (exact_lo_part + pre_sub_poly))
poly.set_tag("poly")
# optimizing poly before evaluation error computation
#opt_poly = self.opt_engine.optimization_process(poly, self.precision, fuse_fma = fuse_fma)
#opt_sub_poly = self.opt_engine.optimization_process(pre_sub_poly, self.precision, fuse_fma = fuse_fma)
opt_poly = self.optimise_scheme(poly)
opt_sub_poly = self.optimise_scheme(pre_sub_poly)
# evaluating error of the polynomial approximation
r_gappa_var = Variable("r",
precision=self.precision,
interval=approx_interval)
exact_hi_gappa_var = Variable("exact_hi",
precision=self.precision,
interval=exact_hi_interval)
exact_lo_gappa_var = Variable("exact_lo",
precision=self.precision,
interval=exact_lo_interval)
vx_gappa_var = Variable("x",
precision=self.precision,
interval=interval_vx)
k_gappa_var = Variable("k",
interval=interval_k,
precision=self.precision)
#print "exact_hi interval: ", exact_hi_interval
sub_poly_error_copy_map = {
#r.get_handle().get_node(): r_gappa_var,
#vx.get_handle().get_node(): vx_gappa_var,
exact_hi_part.get_handle().get_node():
exact_hi_gappa_var,
exact_lo_part.get_handle().get_node():
exact_lo_gappa_var,
#k.get_handle().get_node(): k_gappa_var,
}
poly_error_copy_map = {
exact_hi_part.get_handle().get_node(): exact_hi_gappa_var,
exact_lo_part.get_handle().get_node(): exact_lo_gappa_var,
}
if is_gappa_installed():
sub_poly_eval_error = -1.0
sub_poly_eval_error = self.gappa_engine.get_eval_error_v2(
self.opt_engine,
opt_sub_poly,
sub_poly_error_copy_map,
gappa_filename="%s_gappa_sub_poly.g" % self.function_name)
dichotomy_map = [
{
exact_hi_part.get_handle().get_node():
approx_interval_split[0],
},
{
exact_hi_part.get_handle().get_node():
approx_interval_split[1],
},
{
exact_hi_part.get_handle().get_node():
approx_interval_split[2],
},
]
poly_eval_error_dico = self.gappa_engine.get_eval_error_v3(
self.opt_engine,
opt_poly,
poly_error_copy_map,
gappa_filename="gappa_poly.g",
dichotomy=dichotomy_map)
poly_eval_error = max(
[sup(abs(err)) for err in poly_eval_error_dico])
else:
poly_eval_error = 0.0
sub_poly_eval_error = 0.0
Log.report(Log.Warning,
"gappa is not installed in this environnement")
Log.report(Log.Info, "stopping autonomous degree research")
# incrementing polynomial degree to counteract initial decrementation effect
poly_degree += 1
break
Log.report(Log.Info, "poly evaluation error: %s" % poly_eval_error)
Log.report(Log.Info,
"sub poly evaluation error: %s" % sub_poly_eval_error)
global_poly_error = None
global_rel_poly_error = None
for case_index in range(3):
poly_error = poly_approx_error + poly_eval_error_dico[
case_index]
rel_poly_error = sup(
abs(poly_error /
sollya.exp(approx_interval_split[case_index])))
if global_rel_poly_error == None or rel_poly_error > global_rel_poly_error:
global_rel_poly_error = rel_poly_error
global_poly_error = poly_error
flag = error_goal > global_rel_poly_error
if flag:
break
else:
poly_degree += 1
late_overflow_test = Comparison(ik,
self.precision.get_emax(),
specifier=Comparison.Greater,
likely=False,
debug=debug_multi,
tag="late_overflow_test")
overflow_exp_offset = (self.precision.get_emax() -
self.precision.get_field_size() / 2)
diff_k = Subtraction(
ik,
Constant(overflow_exp_offset,
precision=self.precision.get_integer_format()),
precision=self.precision.get_integer_format(),
debug=debug_multi,
tag="diff_k",
)
late_overflow_result = (ExponentInsertion(
diff_k, precision=self.precision) * poly) * ExponentInsertion(
overflow_exp_offset, precision=self.precision)
late_overflow_result.set_attributes(silent=False,
tag="late_overflow_result",
debug=debug_multi,
precision=self.precision)
late_overflow_return = ConditionBlock(
Test(late_overflow_result, specifier=Test.IsInfty, likely=False),
ExpRaiseReturn(ML_FPE_Overflow,
return_value=FP_PlusInfty(self.precision)),
Return(late_overflow_result, precision=self.precision))
late_underflow_test = Comparison(k,
self.precision.get_emin_normal(),
specifier=Comparison.LessOrEqual,
likely=False)
underflow_exp_offset = 2 * self.precision.get_field_size()
corrected_exp = Addition(
ik,
Constant(underflow_exp_offset,
precision=self.precision.get_integer_format()),
precision=self.precision.get_integer_format(),
tag="corrected_exp")
late_underflow_result = (
ExponentInsertion(corrected_exp, precision=self.precision) *
poly) * ExponentInsertion(-underflow_exp_offset,
precision=self.precision)
late_underflow_result.set_attributes(debug=debug_multi,
tag="late_underflow_result",
silent=False)
test_subnormal = Test(late_underflow_result,
specifier=Test.IsSubnormal)
late_underflow_return = Statement(
ConditionBlock(
test_subnormal,
ExpRaiseReturn(ML_FPE_Underflow,
return_value=late_underflow_result)),
Return(late_underflow_result, precision=self.precision))
twok = ExponentInsertion(ik,
tag="exp_ik",
debug=debug_multi,
precision=self.precision)
#std_result = twok * ((1 + exact_hi_part * pre_poly) + exact_lo_part * pre_poly)
std_result = twok * poly
std_result.set_attributes(tag="std_result", debug=debug_multi)
result_scheme = ConditionBlock(
late_overflow_test, late_overflow_return,
ConditionBlock(late_underflow_test, late_underflow_return,
Return(std_result, precision=self.precision)))
std_return = ConditionBlock(
early_overflow_test, early_overflow_return,
ConditionBlock(early_underflow_test, early_underflow_return,
result_scheme))
# main scheme
Log.report(Log.Info, "\033[33;1m MDL scheme \033[0m")
scheme = ConditionBlock(
test_nan_or_inf,
Statement(ClearException() if self.libm_compliant else Statement(),
specific_return), std_return)
return scheme
def piecewise_approximation(function,
variable,
precision,
bound_low=-1.0,
bound_high=1.0,
num_intervals=16,
max_degree=2,
error_threshold=S2**-24,
odd=False,
even=False):
""" Generate a piecewise approximation
:param function: function to be approximated
:type function: SollyaObject
:param variable: input variable
:type variable: Variable
:param precision: variable's format
:type precision: ML_Format
:param bound_low: lower bound for the approximation interval
:param bound_high: upper bound for the approximation interval
:param num_intervals: number of sub-interval / sub-division of the main interval
:param max_degree: maximum degree for an approximation on any sub-interval
:param error_threshold: error bound for an approximation on any sub-interval
:return: pair (scheme, error) where scheme is a graph node for an
approximation scheme of function evaluated at variable, and error
is the maximum approximation error encountered
:rtype tuple(ML_Operation, SollyaObject): """
degree_generator = piecewise_approximation_degree_generator(
function,
bound_low,
bound_high,
num_intervals=num_intervals,
error_threshold=error_threshold,
)
degree_list = list(degree_generator)
# if max_degree is None then we determine it locally
if max_degree is None:
max_degree = max(degree_list)
# table to store coefficients of the approximation on each segment
coeff_table = ML_NewTable(
dimensions=[num_intervals, max_degree + 1],
storage_precision=precision,
tag="coeff_table",
const=True # by default all approximation coeff table are const
)
error_function = lambda p, f, ai, mod, t: sollya.dirtyinfnorm(p - f, ai)
max_approx_error = 0.0
interval_size = (bound_high - bound_low) / num_intervals
for i in range(num_intervals):
subint_low = bound_low + i * interval_size
subint_high = bound_low + (i + 1) * interval_size
local_function = function(sollya.x + subint_low)
local_interval = Interval(-interval_size, interval_size)
local_degree = degree_list[i]
if local_degree > max_degree:
Log.report(
Log.Warning,
"local_degree {} exceeds max_degree bound ({}) in piecewise_approximation",
local_degree, max_degree)
# as max_degree defines the size of the table we can use
# it as the degree for each sub-interval polynomial
# as there is nothing to gain (yet) by using a smaller polynomial
degree = max_degree # min(max_degree, local_degree)
if function(subint_low) == 0.0:
# if the lower bound is a zero to the function, we
# need to force value=0 for the constant coefficient
# and extend the approximation interval
local_poly_degree_list = list(
range(1 if even else 0, degree + 1, 2 if odd or even else 1))
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
function(sollya.x) / sollya.x,
local_poly_degree_list,
[precision] * len(local_poly_degree_list),
Interval(-subint_high * 0.95, subint_high),
sollya.absolute,
error_function=error_function)
# multiply by sollya.x
poly_object = poly_object.sub_poly(offset=-1)
else:
try:
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
local_function,
degree, [precision] * (degree + 1),
local_interval,
sollya.absolute,
error_function=error_function)
except SollyaError as err:
# try to see if function is constant on the interval (possible
# failure cause for fpminmax)
cst_value = precision.round_sollya_object(
function(subint_low), sollya.RN)
accuracy = error_threshold
diff_with_cst_range = sollya.supnorm(cst_value, local_function,
local_interval,
sollya.absolute, accuracy)
diff_with_cst = sup(abs(diff_with_cst_range))
if diff_with_cst < error_threshold:
Log.report(Log.Info, "constant polynomial detected")
poly_object = Polynomial([function(subint_low)] +
[0] * degree)
approx_error = diff_with_cst
else:
Log.report(
Log.error,
"degree: {} for index {}, diff_with_cst={} (vs error_threshold={}) ",
degree,
i,
diff_with_cst,
error_threshold,
error=err)
for ci in range(max_degree + 1):
if ci in poly_object.coeff_map:
coeff_table[i][ci] = poly_object.coeff_map[ci]
else:
coeff_table[i][ci] = 0.0
if approx_error > error_threshold:
Log.report(
Log.Warning,
"piecewise_approximation on index {} exceeds error threshold: {} > {}",
i, approx_error, error_threshold)
max_approx_error = max(max_approx_error, abs(approx_error))
# computing offset
diff = Subtraction(variable,
Constant(bound_low, precision=precision),
tag="diff",
debug=debug_multi,
precision=precision)
int_prec = precision.get_integer_format()
# delta = bound_high - bound_low
delta_ratio = Constant(num_intervals / (bound_high - bound_low),
precision=precision)
# computing table index
# index = nearestint(diff / delta * <num_intervals>)
index = Max(0,
Min(
NearestInteger(
Multiplication(diff, delta_ratio, precision=precision),
precision=int_prec,
), num_intervals - 1),
tag="index",
debug=debug_multi,
precision=int_prec)
poly_var = Subtraction(diff,
Multiplication(
Conversion(index, precision=precision),
Constant(interval_size, precision=precision)),
precision=precision,
tag="poly_var",
debug=debug_multi)
# generating indexed polynomial
coeffs = [(ci, TableLoad(coeff_table, index, ci))
for ci in range(max_degree + 1)][::-1]
poly_scheme = PolynomialSchemeEvaluator.generate_horner_scheme2(
coeffs, poly_var, precision, {}, precision)
return poly_scheme, max_approx_error
def generic_poly_split(offset_fct, indexing, target_eps, coeff_precision, vx):
""" generate the meta approximation for @p offset_fct over several
intervals defined by @p indexing object
For each sub-interval, a polynomial approximation with
maximal_error @p target_eps is tabulated, and evaluated using format
@p coeff_precision.
The input variable is @p vx """
# computing degree for a different polynomial approximation on each
# sub-interval
poly_degree_list = [
int(sup(guessdegree(offset_fct(offset), sub_interval, target_eps)))
for offset, sub_interval in indexing.get_offseted_sub_list()
]
poly_max_degree = max(poly_degree_list)
# tabulating polynomial coefficients on split_num sub-interval of interval
poly_table = ML_NewTable(
dimensions=[indexing.split_num, poly_max_degree + 1],
storage_precision=coeff_precision,
const=True)
offset_table = ML_NewTable(dimensions=[indexing.split_num],
storage_precision=coeff_precision,
const=True)
max_error = 0.0
for sub_index in range(indexing.split_num):
poly_degree = poly_degree_list[sub_index]
offset, approx_interval = indexing.get_offseted_sub_interval(sub_index)
offset_table[sub_index] = offset
if poly_degree == 0:
# managing constant approximation separately since it seems
# to break sollya
local_approx = coeff_precision.round_sollya_object(
offset_fct(offset)(inf(approx_interval)))
poly_table[sub_index][0] = local_approx
for monomial_index in range(1, poly_max_degree + 1):
poly_table[sub_index][monomial_index] = 0
approx_error = sollya.infnorm(
offset_fct(offset) - local_approx, approx_interval)
else:
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
offset_fct(offset), poly_degree,
[coeff_precision] * (poly_degree + 1), approx_interval,
sollya.relative)
for monomial_index in range(poly_max_degree + 1):
if monomial_index <= poly_degree:
poly_table[sub_index][
monomial_index] = poly_object.coeff_map[monomial_index]
else:
poly_table[sub_index][monomial_index] = 0
max_error = max(approx_error, max_error)
Log.report(Log.Debug, "max approx error is {}", max_error)
# indexing function: derive index from input @p vx value
poly_index = indexing.get_index_node(vx)
poly_index.set_attributes(tag="poly_index", debug=debug_multi)
ext_precision = get_extended_fp_precision(coeff_precision)
# building polynomial evaluation scheme
offset = TableLoad(offset_table,
poly_index,
precision=coeff_precision,
tag="offset",
debug=debug_multi)
poly = TableLoad(poly_table,
poly_index,
poly_max_degree,
precision=coeff_precision,
tag="poly_init",
debug=debug_multi)
red_vx = Subtraction(vx,
offset,
precision=vx.precision,
tag="red_vx",
debug=debug_multi)
for monomial_index in range(poly_max_degree, -1, -1):
coeff = TableLoad(poly_table,
poly_index,
monomial_index,
precision=coeff_precision,
tag="poly_%d" % monomial_index,
debug=debug_multi)
#fma_precision = coeff_precision if monomial_index > 1 else ext_precision
fma_precision = coeff_precision
poly = FMA(red_vx, poly, coeff, precision=fma_precision)
#return Conversion(poly, precision=coeff_precision)
#return poly.hi
return poly
def generate_scalar_scheme(self, vx):
# approximation the gamma function
abs_vx = Abs(vx, precision=self.precision)
FCT_LIMIT = 1.0
omega_value = self.precision.get_omega()
def sollya_wrap_bigfloat_fct(bfct):
""" wrap bigfloat's function <bfct> such that is can be used
on SollyaObject inputs and returns SollyaObject results """
def fct(x):
return sollya.SollyaObject(bfct(SollyaObject(x).bigfloat()))
return fct
sollya_gamma = sollya_wrap_bigfloat_fct(bigfloat.gamma)
sollya_digamma = sollya_wrap_bigfloat_fct(bigfloat.digamma)
# first derivative of gamma is digamma * gamma
bigfloat_gamma_d0 = lambda x: bigfloat.gamma(x) * bigfloat.digamma(x)
sollya_gamma_d0 = sollya_wrap_bigfloat_fct(bigfloat_gamma_d0)
# approximating trigamma with straightforward derivatives formulae of digamma
U = 2**-64
bigfloat_trigamma = lambda x: (
(bigfloat.digamma(x * (1 + U)) - bigfloat.digamma(x)) / (x * U))
sollya_trigamma = sollya_wrap_bigfloat_fct(bigfloat_trigamma)
bigfloat_gamma_d1 = lambda x: (bigfloat_trigamma(x) * bigfloat.gamma(
x) + bigfloat_gamma_d0(x) * bigfloat.digamma(x))
sollya_gamma_d1 = sollya_wrap_bigfloat_fct(bigfloat_gamma_d1)
def sollya_gamma_fct(x, diff_order, prec):
""" wrapper to use bigfloat implementation of exponential
rather than sollya's implementation directly.
This wrapper implements sollya's function API.
:param x: numerical input value (may be an Interval)
:param diff_order: differential order
:param prec: numerical precision expected (min)
"""
fct = None
if diff_order == 0:
fct = sollya_gamma
elif diff_order == 1:
fct = sollya_gamma_d0
elif diff_order == 2:
fct = sollya_gamma_d1
else:
raise NotImplementedError
with bigfloat.precision(prec):
if x.is_range():
lo = sollya.inf(x)
hi = sollya.sup(x)
return sollya.Interval(fct(lo), fct(hi))
else:
return fct(x)
# search the lower x such that gamma(x) >= omega
omega_upper_limit = search_bound_threshold(sollya_gamma, omega_value,
2, 1000.0, self.precision)
Log.report(Log.Debug, "gamma(x) = {} limit is {}", omega_value,
omega_upper_limit)
# evaluate gamma(<min-normal-value>)
lower_x_bound = self.precision.get_min_normal_value()
value_min = sollya_gamma(lower_x_bound)
Log.report(Log.Debug, "gamma({}) = {}(log2={})", lower_x_bound,
value_min, int(sollya.log2(value_min)))
# evaluate gamma(<min-subnormal-value>)
lower_x_bound = self.precision.get_min_subnormal_value()
value_min = sollya_gamma(lower_x_bound)
Log.report(Log.Debug, "gamma({}) = {}(log2={})", lower_x_bound,
value_min, int(sollya.log2(value_min)))
# Gamma is defined such that gamma(x+1) = x * gamma(x)
#
# we approximate gamma over [1, 2]
# y in [1, 2]
# gamma(y) = (y-1) * gamma(y-1)
# gamma(y-1) = gamma(y) / (y-1)
Log.report(Log.Info, "building mathematical polynomial")
approx_interval = Interval(1, 2)
approx_fct = sollya.function(sollya_gamma_fct)
poly_degree = int(
sup(
guessdegree(approx_fct, approx_interval, S2**
-(self.precision.get_field_size() + 5)))) + 1
Log.report(Log.Debug, "approximation's poly degree over [1, 2] is {}",
poly_degree)
sys.exit(1)
poly_degree_list = list(range(1, poly_degree, 2))
Log.report(Log.Debug, "poly_degree is {} and list {}", poly_degree,
poly_degree_list)
global_poly_object = Polynomial.build_from_approximation(
approx_fct, poly_degree_list,
[self.precision] * len(poly_degree_list), approx_interval,
sollya.relative)
Log.report(
Log.Debug, "inform is {}",
dirtyinfnorm(approx_fct - global_poly_object.get_sollya_object(),
approx_interval))
poly_object = global_poly_object.sub_poly(start_index=1, offset=1)
ext_precision = {
ML_Binary32: ML_SingleSingle,
ML_Binary64: ML_DoubleDouble,
}[self.precision]
pre_poly = PolynomialSchemeEvaluator.generate_horner_scheme(
poly_object, abs_vx, unified_precision=self.precision)
result = FMA(pre_poly, abs_vx, abs_vx)
result.set_attributes(tag="result", debug=debug_multi)
eps_target = S2**-(self.precision.get_field_size() + 5)
def offset_div_function(fct):
return lambda offset: fct(sollya.x + offset)
# empiral numbers
field_size = {ML_Binary32: 6, ML_Binary64: 8}[self.precision]
near_indexing = SubFPIndexing(eps_exp, 0, 6, self.precision)
near_approx = generic_poly_split(offset_div_function(sollya.erf),
near_indexing, eps_target,
self.precision, abs_vx)
near_approx.set_attributes(tag="near_approx", debug=debug_multi)
def offset_function(fct):
return lambda offset: fct(sollya.x + offset)
medium_indexing = SubFPIndexing(1, one_limit_exp, 7, self.precision)
medium_approx = generic_poly_split(offset_function(sollya.erf),
medium_indexing, eps_target,
self.precision, abs_vx)
medium_approx.set_attributes(tag="medium_approx", debug=debug_multi)
# approximation for positive values
scheme = ConditionBlock(
abs_vx < eps, Return(result),
ConditionBlock(
abs_vx < near_indexing.get_max_bound(), Return(near_approx),
ConditionBlock(abs_vx < medium_indexing.get_max_bound(),
Return(medium_approx),
Return(Constant(1.0,
precision=self.precision)))))
return scheme
def generate_scalar_scheme(self, vx):
Log.set_dump_stdout(True)
Log.report(Log.Info, "\033[33;1m generating implementation scheme \033[0m")
if self.debug_flag:
Log.report(Log.Info, "\033[31;1m debug has been enabled \033[0;m")
index_size = 5
comp_lo = (vx < 0)
comp_lo.set_attributes(tag = "comp_lo", precision = ML_Bool)
sign = Select(comp_lo, -1, 1, precision = self.precision)
# as sinh is an odd function, we can simplify the input to its absolute
# value once the sign has been extracted
vx = Abs(vx)
int_precision = self.precision.get_integer_format()
# argument reduction
arg_reg_value = log(2)/2**index_size
inv_log2_value = round(1/arg_reg_value, self.precision.get_sollya_object(), sollya.RN)
inv_log2_cst = Constant(inv_log2_value, precision = self.precision, tag = "inv_log2")
# for r_hi to be accurate we ensure k * log2_hi_value_cst is exact
# by limiting the number of non-zero bits in log2_hi_value_cst
# cosh(x) ~ exp(abs(x))/2 for a big enough x
# cosh(x) > 2^1023 <=> exp(x) > 2^1024 <=> x > log(2^1024)
# k = inv_log2_value * x
# -1 for guard
max_k_approx = inv_log2_value * log(sollya.SollyaObject(2)**1024)
max_k_bitsize = int(ceil(log2(max_k_approx)))
Log.report(Log.Info, "max_k_bitsize: %d" % max_k_bitsize)
log2_hi_value_precision = self.precision.get_precision() - max_k_bitsize - 1
log2_hi_value = round(arg_reg_value, log2_hi_value_precision, sollya.RN)
log2_lo_value = round(arg_reg_value - log2_hi_value, self.precision.get_sollya_object(), sollya.RN)
log2_hi_value_cst = Constant(log2_hi_value, tag = "log2_hi_value", precision = self.precision)
log2_lo_value_cst = Constant(log2_lo_value, tag = "log2_lo_value", precision = self.precision)
k = Trunc(Multiplication(inv_log2_cst, vx), precision = self.precision)
k_log2 = Multiplication(k, log2_hi_value_cst, precision = self.precision, exact = True, tag = "k_log2", unbreakable = True)
r_hi = vx - k_log2
r_hi.set_attributes(tag = "r_hi", debug = debug_multi, unbreakable = True)
r_lo = -k * log2_lo_value_cst
# reduced argument
r = r_hi + r_lo
r.set_attributes(tag = "r", debug = debug_multi)
if is_gappa_installed():
r_eval_error = self.get_eval_error(r_hi, variable_copy_map =
{
vx: Variable("vx", interval = Interval(0, 715), precision = self.precision),
k: Variable("k", interval = Interval(0, 1024), precision = self.precision)
})
Log.report(Log.Verbose, "r_eval_error: ", r_eval_error)
approx_interval = Interval(-arg_reg_value, arg_reg_value)
error_goal_approx = 2**-(self.precision.get_precision())
poly_degree = sup(guessdegree(exp(sollya.x), approx_interval, error_goal_approx)) + 3
precision_list = [1] + [self.precision] * (poly_degree)
k_integer = Conversion(k, precision = int_precision, tag = "k_integer", debug = debug_multi)
k_hi = BitLogicRightShift(k_integer, Constant(index_size, precision=int_precision), tag = "k_int_hi", precision = int_precision, debug = debug_multi)
k_lo = Modulo(k_integer, 2**index_size, tag = "k_int_lo", precision = int_precision, debug = debug_multi)
pow_exp = ExponentInsertion(Conversion(k_hi, precision = int_precision), precision = self.precision, tag = "pow_exp", debug = debug_multi)
exp_table = ML_NewTable(dimensions = [2 * 2**index_size, 4], storage_precision = self.precision, tag = self.uniquify_name("exp2_table"))
for i in range(2 * 2**index_size):
input_value = i - 2**index_size if i >= 2**index_size else i
reduced_hi_prec = int(self.precision.get_mantissa_size() - 8)
# using SollyaObject wrapper to force evaluation by sollya
# with higher precision
exp_value = sollya.SollyaObject(2)**((input_value)* 2**-index_size)
mexp_value = sollya.SollyaObject(2)**((-input_value)* 2**-index_size)
pos_value_hi = round(exp_value, reduced_hi_prec, sollya.RN)
pos_value_lo = round(exp_value - pos_value_hi, self.precision.get_sollya_object(), sollya.RN)
neg_value_hi = round(mexp_value, reduced_hi_prec, sollya.RN)
neg_value_lo = round(mexp_value - neg_value_hi, self.precision.get_sollya_object(), sollya.RN)
exp_table[i][0] = neg_value_hi
exp_table[i][1] = neg_value_lo
exp_table[i][2] = pos_value_hi
exp_table[i][3] = pos_value_lo
# log2_value = log(2) / 2^index_size
# sinh(x) = 1/2 * (exp(x) - exp(-x))
# exp(x) = exp(x - k * log2_value + k * log2_value)
#
# r = x - k * log2_value
# exp(x) = exp(r) * 2 ^ (k / 2^index_size)
#
# k / 2^index_size = h + l * 2^-index_size, with k, h, l integers
# exp(x) = exp(r) * 2^h * 2^(l *2^-index_size)
#
# sinh(x) = exp(r) * 2^(h-1) * 2^(l *2^-index_size) - exp(-r) * 2^(-h-1) * 2^(-l *2^-index_size)
# S=2^(h-1), T = 2^(-h-1)
# exp(r) = 1 + poly_pos(r)
# exp(-r) = 1 + poly_neg(r)
# 2^(l / 2^index_size) = pos_value_hi + pos_value_lo
# 2^(-l / 2^index_size) = neg_value_hi + neg_value_lo
#
error_function = lambda p, f, ai, mod, t: dirtyinfnorm(f - p, ai)
poly_object, poly_approx_error = Polynomial.build_from_approximation_with_error(exp(sollya.x), poly_degree, precision_list, approx_interval, sollya.absolute, error_function = error_function)
Log.report(Log.Verbose, "poly_approx_error: {}, {}".format(poly_approx_error, float(log2(poly_approx_error))))
polynomial_scheme_builder = PolynomialSchemeEvaluator.generate_horner_scheme
poly_pos = polynomial_scheme_builder(poly_object.sub_poly(start_index = 1), r, unified_precision = self.precision)
poly_pos.set_attributes(tag = "poly_pos", debug = debug_multi)
poly_neg = polynomial_scheme_builder(poly_object.sub_poly(start_index = 1), -r, unified_precision = self.precision)
poly_neg.set_attributes(tag = "poly_neg", debug = debug_multi)
table_index = Addition(k_lo, Constant(2**index_size, precision = int_precision), precision = int_precision, tag = "table_index", debug = debug_multi)
neg_value_load_hi = TableLoad(exp_table, table_index, 0, tag = "neg_value_load_hi", debug = debug_multi)
neg_value_load_lo = TableLoad(exp_table, table_index, 1, tag = "neg_value_load_lo", debug = debug_multi)
pos_value_load_hi = TableLoad(exp_table, table_index, 2, tag = "pos_value_load_hi", debug = debug_multi)
pos_value_load_lo = TableLoad(exp_table, table_index, 3, tag = "pos_value_load_lo", debug = debug_multi)
k_plus = Max(
Subtraction(k_hi, Constant(1, precision = int_precision), precision=int_precision, tag="k_plus", debug=debug_multi),
Constant(self.precision.get_emin_normal(), precision = int_precision))
k_neg = Max(
Subtraction(-k_hi, Constant(1, precision=int_precision), precision=int_precision, tag="k_neg", debug=debug_multi),
Constant(self.precision.get_emin_normal(), precision = int_precision))
# 2^(h-1)
pow_exp_pos = ExponentInsertion(k_plus, precision = self.precision, tag="pow_exp_pos", debug=debug_multi)
# 2^(-h-1)
pow_exp_neg = ExponentInsertion(k_neg, precision = self.precision, tag="pow_exp_neg", debug=debug_multi)
hi_terms = (pos_value_load_hi * pow_exp_pos - neg_value_load_hi * pow_exp_neg)
hi_terms.set_attributes(tag = "hi_terms", debug=debug_multi)
pos_exp = (pos_value_load_hi * poly_pos + (pos_value_load_lo + pos_value_load_lo * poly_pos)) * pow_exp_pos
pos_exp.set_attributes(tag = "pos_exp", debug = debug_multi)
neg_exp = (neg_value_load_hi * poly_neg + (neg_value_load_lo + neg_value_load_lo * poly_neg)) * pow_exp_neg
neg_exp.set_attributes(tag = "neg_exp", debug = debug_multi)
result = Addition(
Subtraction(
pos_exp,
neg_exp,
precision=self.precision,
),
hi_terms,
precision=self.precision,
tag="result",
debug=debug_multi
)
# ov_value
ov_value = round(asinh(self.precision.get_max_value()), self.precision.get_sollya_object(), sollya.RD)
ov_flag = Comparison(Abs(vx), Constant(ov_value, precision = self.precision), specifier = Comparison.Greater)
# main scheme
scheme = Statement(
Return(
Select(
ov_flag,
sign*FP_PlusInfty(self.precision),
sign*result
)))
return scheme
def generate_scalar_scheme(self, vx):
abs_vx = Abs(vx, precision=self.precision)
FCT_LIMIT = 1.0
one_limit = search_bound_threshold(sollya.erf, FCT_LIMIT, 1.0, 10.0,
self.precision)
one_limit_exp = int(sollya.floor(sollya.log2(one_limit)))
Log.report(Log.Debug, "erf(x) = 1.0 limit is {}, with exp={}",
one_limit, one_limit_exp)
upper_approx_bound = 10
# empiral numbers
eps_exp = {ML_Binary32: -3, ML_Binary64: -5}[self.precision]
eps = S2**eps_exp
Log.report(Log.Info, "building mathematical polynomial")
approx_interval = Interval(0, eps)
# fonction to approximate is erf(x) / x
# it is an even function erf(x) / x = erf(-x) / (-x)
approx_fct = sollya.erf(sollya.x) - (sollya.x)
poly_degree = int(
sup(
guessdegree(approx_fct, approx_interval, S2**
-(self.precision.get_field_size() + 5)))) + 1
poly_degree_list = list(range(1, poly_degree, 2))
Log.report(Log.Debug, "poly_degree is {} and list {}", poly_degree,
poly_degree_list)
global_poly_object = Polynomial.build_from_approximation(
approx_fct, poly_degree_list,
[self.precision] * len(poly_degree_list), approx_interval,
sollya.relative)
Log.report(
Log.Debug, "inform is {}",
dirtyinfnorm(approx_fct - global_poly_object.get_sollya_object(),
approx_interval))
poly_object = global_poly_object.sub_poly(start_index=1, offset=1)
ext_precision = {
ML_Binary32: ML_SingleSingle,
ML_Binary64: ML_DoubleDouble,
}[self.precision]
pre_poly = PolynomialSchemeEvaluator.generate_horner_scheme(
poly_object, abs_vx, unified_precision=self.precision)
result = FMA(pre_poly, abs_vx, abs_vx)
result.set_attributes(tag="result", debug=debug_multi)
eps_target = S2**-(self.precision.get_field_size() + 5)
def offset_div_function(fct):
return lambda offset: fct(sollya.x + offset)
# empiral numbers
field_size = {ML_Binary32: 6, ML_Binary64: 8}[self.precision]
near_indexing = SubFPIndexing(eps_exp, 0, 6, self.precision)
near_approx = generic_poly_split(offset_div_function(sollya.erf),
near_indexing, eps_target,
self.precision, abs_vx)
near_approx.set_attributes(tag="near_approx", debug=debug_multi)
def offset_function(fct):
return lambda offset: fct(sollya.x + offset)
medium_indexing = SubFPIndexing(1, one_limit_exp, 7, self.precision)
medium_approx = generic_poly_split(offset_function(sollya.erf),
medium_indexing, eps_target,
self.precision, abs_vx)
medium_approx.set_attributes(tag="medium_approx", debug=debug_multi)
# approximation for positive values
scheme = ConditionBlock(
abs_vx < eps, Return(result),
ConditionBlock(
abs_vx < near_indexing.get_max_bound(), Return(near_approx),
ConditionBlock(abs_vx < medium_indexing.get_max_bound(),
Return(medium_approx),
Return(Constant(1.0,
precision=self.precision)))))
return scheme
def generate_scheme(self):
# declaring CodeFunction and retrieving input variable
vx = self.implementation.add_input_variable("x", self.precision)
table_size_log = self.table_size_log
integer_size = 31
integer_precision = ML_Int32
max_bound = sup(abs(self.input_intervals[0]))
max_bound_log = int(ceil(log2(max_bound)))
Log.report(Log.Info, "max_bound_log=%s " % max_bound_log)
scaling_power = integer_size - max_bound_log
Log.report(Log.Info, "scaling power: %s " % scaling_power)
storage_precision = ML_Custom_FixedPoint_Format(1, 30, signed=True)
Log.report(Log.Info, "tabulating cosine and sine")
# cosine and sine fused table
fused_table = ML_NewTable(
dimensions=[2**table_size_log, 2],
storage_precision=storage_precision,
tag="fast_lib_shared_table") # self.uniquify_name("cossin_table"))
# filling table
for i in range(2**table_size_log):
local_x = i / S2**table_size_log * S2**max_bound_log
cos_local = cos(
local_x
) # nearestint(cos(local_x) * S2**storage_precision.get_frac_size())
sin_local = sin(
local_x
) # nearestint(sin(local_x) * S2**storage_precision.get_frac_size())
fused_table[i][0] = cos_local
fused_table[i][1] = sin_local
# argument reduction evaluation scheme
# scaling_factor = Constant(S2**scaling_power, precision = self.precision)
red_vx_precision = ML_Custom_FixedPoint_Format(31 - scaling_power,
scaling_power,
signed=True)
Log.report(
Log.Verbose, "red_vx_precision.get_c_bit_size()=%d" %
red_vx_precision.get_c_bit_size())
# red_vx = NearestInteger(vx * scaling_factor, precision = integer_precision)
red_vx = Conversion(vx,
precision=red_vx_precision,
tag="red_vx",
debug=debug_fixed32)
computation_precision = red_vx_precision # self.precision
output_precision = self.get_output_precision()
Log.report(Log.Info,
"computation_precision is %s" % computation_precision)
Log.report(Log.Info, "storage_precision is %s" % storage_precision)
Log.report(Log.Info, "output_precision is %s" % output_precision)
hi_mask_value = 2**32 - 2**(32 - table_size_log - 1)
hi_mask = Constant(hi_mask_value, precision=ML_Int32)
Log.report(Log.Info, "hi_mask=0x%x" % hi_mask_value)
red_vx_hi_int = BitLogicAnd(TypeCast(red_vx, precision=ML_Int32),
hi_mask,
precision=ML_Int32,
tag="red_vx_hi_int",
debug=debugd)
red_vx_hi = TypeCast(red_vx_hi_int,
precision=red_vx_precision,
tag="red_vx_hi",
debug=debug_fixed32)
red_vx_lo = red_vx - red_vx_hi
red_vx_lo.set_attributes(precision=red_vx_precision,
tag="red_vx_lo",
debug=debug_fixed32)
table_index = BitLogicRightShift(TypeCast(red_vx, precision=ML_Int32),
scaling_power -
(table_size_log - max_bound_log),
precision=ML_Int32,
tag="table_index",
debug=debugd)
tabulated_cos = TableLoad(fused_table,
table_index,
0,
tag="tab_cos",
precision=storage_precision,
debug=debug_fixed32)
tabulated_sin = TableLoad(fused_table,
table_index,
1,
tag="tab_sin",
precision=storage_precision,
debug=debug_fixed32)
error_function = lambda p, f, ai, mod, t: dirtyinfnorm(f - p, ai)
Log.report(Log.Info, "building polynomial approximation for cosine")
# cosine polynomial approximation
poly_interval = Interval(0, S2**(max_bound_log - table_size_log))
Log.report(Log.Info, "poly_interval=%s " % poly_interval)
cos_poly_degree = 2 # int(sup(guessdegree(cos(x), poly_interval, accuracy_goal)))
Log.report(Log.Verbose, "cosine polynomial approximation")
cos_poly_object, cos_approx_error = Polynomial.build_from_approximation_with_error(
cos(sollya.x), [0, 2],
[0] + [computation_precision.get_bit_size()],
poly_interval,
sollya.absolute,
error_function=error_function)
#cos_eval_scheme = PolynomialSchemeEvaluator.generate_horner_scheme(cos_poly_object, red_vx_lo, unified_precision = computation_precision)
Log.report(Log.Info, "cos_approx_error=%e" % cos_approx_error)
cos_coeff_list = cos_poly_object.get_ordered_coeff_list()
coeff_C0 = cos_coeff_list[0][1]
coeff_C2 = Constant(cos_coeff_list[1][1],
precision=ML_Custom_FixedPoint_Format(-1,
32,
signed=True))
Log.report(Log.Info, "building polynomial approximation for sine")
# sine polynomial approximation
sin_poly_degree = 2 # int(sup(guessdegree(sin(x)/x, poly_interval, accuracy_goal)))
Log.report(Log.Info, "sine poly degree: %e" % sin_poly_degree)
Log.report(Log.Verbose, "sine polynomial approximation")
sin_poly_object, sin_approx_error = Polynomial.build_from_approximation_with_error(
sin(sollya.x) / sollya.x, [0, 2], [0] +
[computation_precision.get_bit_size()] * (sin_poly_degree + 1),
poly_interval,
sollya.absolute,
error_function=error_function)
sin_coeff_list = sin_poly_object.get_ordered_coeff_list()
coeff_S0 = sin_coeff_list[0][1]
coeff_S2 = Constant(sin_coeff_list[1][1],
precision=ML_Custom_FixedPoint_Format(-1,
32,
signed=True))
# scheme selection between sine and cosine
if self.cos_output:
scheme = self.generate_cos_scheme(computation_precision,
tabulated_cos, tabulated_sin,
coeff_S2, coeff_C2, red_vx_lo)
else:
scheme = self.generate_sin_scheme(computation_precision,
tabulated_cos, tabulated_sin,
coeff_S2, coeff_C2, red_vx_lo)
result = Conversion(scheme, precision=self.get_output_precision())
Log.report(
Log.Verbose, "result operation tree :\n %s " % result.get_str(
display_precision=True, depth=None, memoization_map={}))
scheme = Statement(Return(result))
return scheme
def generic_atan2_generate(self, _vx, vy=None):
""" if vy is None, compute atan(_vx), else compute atan2(vy / vx) """
if vy is None:
# approximation
# if abs_vx <= 1.0 then atan(abx_vx) is directly approximated
# if abs_vx > 1.0 then atan(abs_vx) = pi/2 - atan(1 / abs_vx)
#
# for vx >= 0, atan(vx) = atan(abs_vx)
#
# for vx < 0, atan(vx) = -atan(abs_vx) for vx < 0
# = -pi/2 + atan(1 / abs_vx)
vx = _vx
sign_cond = vx < 0
abs_vx = Select(vx < 0, -vx, vx, tag="abs_vx", debug=debug_multi)
bound_cond = abs_vx > 1
inv_abs_vx = 1 / abs_vx
# condition to select subtraction
cond = LogicalOr(LogicalAnd(vx < 0, LogicalNot(bound_cond)),
vx > 1,
tag="cond",
debug=debug_multi)
# reduced argument
red_vx = Select(bound_cond,
inv_abs_vx,
abs_vx,
tag="red_vx",
debug=debug_multi)
offset = None
else:
# bound_cond is True iff Abs(vy / _vx) > 1.0
bound_cond = Abs(vy) > Abs(_vx)
bound_cond.set_attributes(tag="bound_cond", debug=debug_multi)
# vx and vy are of opposite signs
#sign_cond = (_vx * vy) < 0
# using cast to int(signed) and bitwise xor
# to determine if _vx and vy are of opposite sign rapidly
fast_sign_cond = BitLogicXor(
TypeCast(_vx, precision=self.precision.get_integer_format()),
TypeCast(vy, precision=self.precision.get_integer_format()),
precision=self.precision.get_integer_format()) < 0
# sign_cond = (_vx * vy) < 0
sign_cond = fast_sign_cond
sign_cond.set_attributes(tag="sign_cond", debug=debug_multi)
# condition to select subtraction
# TODO: could be accelerated if LogicalXor existed
slow_cond = LogicalOr(
LogicalAnd(sign_cond,
LogicalNot(bound_cond)), # 1 < (vy / _vx) < 0
LogicalAnd(bound_cond,
LogicalNot(sign_cond)), # (vy / _vx) > 1
tag="cond",
debug=debug_multi)
cond = slow_cond
numerator = Select(bound_cond,
_vx,
vy,
tag="numerator",
debug=debug_multi)
denominator = Select(bound_cond,
vy,
_vx,
tag="denominator",
debug=debug_multi)
# reduced argument
red_vx = Abs(numerator) / Abs(denominator)
red_vx.set_attributes(tag="red_vx", debug=debug_multi)
offset = Select(
_vx > 0,
Constant(0, precision=self.precision),
# vx < 0
Select(
sign_cond,
# vy > 0
Constant(sollya.pi, precision=self.precision),
Constant(-sollya.pi, precision=self.precision),
precision=self.precision),
precision=self.precision,
tag="offset")
approx_fct = sollya.atan(sollya.x)
if self.method == "piecewise":
sign_vx = Select(cond,
-1,
1,
precision=self.precision,
tag="sign_vx",
debug=debug_multi)
cst_sign = Select(sign_cond,
-1,
1,
precision=self.precision,
tag="cst_sign",
debug=debug_multi)
cst = cst_sign * Select(
bound_cond, sollya.pi / 2, 0, precision=self.precision)
cst.set_attributes(tag="cst", debug=debug_multi)
bound_low = 0.0
bound_high = 1.0
num_intervals = self.num_sub_intervals
error_threshold = S2**-(self.precision.get_mantissa_size() + 8)
approx, eval_error = piecewise_approximation(
approx_fct,
red_vx,
self.precision,
bound_low=bound_low,
bound_high=bound_high,
max_degree=None,
num_intervals=num_intervals,
error_threshold=error_threshold,
odd=True)
result = cst + sign_vx * approx
result.set_attributes(tag="result",
precision=self.precision,
debug=debug_multi)
elif self.method == "single":
approx_interval = Interval(0, 1.0)
# determining the degree of the polynomial approximation
poly_degree_range = sollya.guessdegree(
approx_fct / sollya.x, approx_interval,
S2**-(self.precision.get_field_size() + 2))
poly_degree = int(sollya.sup(poly_degree_range)) + 4
Log.report(Log.Info, "poly_degree={}".format(poly_degree))
# arctan is an odd function, so only odd coefficient must be non-zero
poly_degree_list = list(range(1, poly_degree + 1, 2))
poly_object, poly_error = Polynomial.build_from_approximation_with_error(
approx_fct, poly_degree_list,
[1] + [self.precision.get_sollya_object()] *
(len(poly_degree_list) - 1), approx_interval)
odd_predicate = lambda index, _: ((index - 1) % 4 != 0)
even_predicate = lambda index, _: (index != 1 and
(index - 1) % 4 == 0)
poly_odd_object = poly_object.sub_poly_cond(odd_predicate,
offset=1)
poly_even_object = poly_object.sub_poly_cond(even_predicate,
offset=1)
sollya.settings.display = sollya.hexadecimal
Log.report(Log.Info, "poly_error: {}".format(poly_error))
Log.report(Log.Info, "poly_odd: {}".format(poly_odd_object))
Log.report(Log.Info, "poly_even: {}".format(poly_even_object))
poly_odd = PolynomialSchemeEvaluator.generate_horner_scheme(
poly_odd_object, abs_vx)
poly_odd.set_attributes(tag="poly_odd", debug=debug_multi)
poly_even = PolynomialSchemeEvaluator.generate_horner_scheme(
poly_even_object, abs_vx)
poly_even.set_attributes(tag="poly_even", debug=debug_multi)
exact_sum = poly_odd + poly_even
exact_sum.set_attributes(tag="exact_sum", debug=debug_multi)
# poly_even should be (1 + poly_even)
result = vx + vx * exact_sum
result.set_attributes(tag="result",
precision=self.precision,
debug=debug_multi)
else:
raise NotImplementedError
if not offset is None:
result = result + offset
std_scheme = Statement(Return(result))
scheme = std_scheme
return scheme
def generate_scheme(self):
vx = self.implementation.add_input_variable("x", self.precision)
sollya_precision = self.get_input_precision().sollya_object
# local overloading of RaiseReturn operation
def ExpRaiseReturn(*args, **kwords):
kwords["arg_value"] = vx
kwords["function_name"] = self.function_name
return RaiseReturn(*args, **kwords)
# 2-limb approximation of log(2)
# hi part precision is reduced to provide exact operation
# when multiplied by an exponent value
log2_hi_value = round(log(2), self.precision.get_field_size() - (self.precision.get_exponent_size() + 1), sollya.RN)
log2_lo_value = round(log(2) - log2_hi_value, self.precision.sollya_object, sollya.RN)
log2_hi = Constant(log2_hi_value, precision=self.precision)
log2_lo = Constant(log2_lo_value, precision=self.precision)
int_precision = self.precision.get_integer_format()
# retrieving processor inverse approximation table
dummy_var = Variable("dummy", precision = self.precision)
dummy_rcp_seed = ReciprocalSeed(dummy_var, precision = self.precision)
inv_approx_table = self.processor.get_recursive_implementation(dummy_rcp_seed, language = None, table_getter = lambda self: self.approx_table_map)
# table creation
table_index_size = inv_approx_table.index_size
log_table = ML_NewTable(dimensions = [2**table_index_size, 2], storage_precision = self.precision)
# storing accurate logarithm approximation of value returned
# by the fast reciprocal operation
for i in range(0, 2**table_index_size):
inv_value = inv_approx_table[i]
value_high = round(log(inv_value), self.precision.get_field_size() - (self.precision.get_exponent_size() + 1), sollya.RN)
value_low = round(log(inv_value) - value_high, sollya_precision, sollya.RN)
log_table[i][0] = value_high
log_table[i][1] = value_low
neg_input = Comparison(vx, -1, likely=False, precision=ML_Bool, specifier=Comparison.Less, debug=debug_multi, tag="neg_input")
vx_nan_or_inf = Test(vx, specifier=Test.IsInfOrNaN, likely=False, precision=ML_Bool, debug=debug_multi, tag="nan_or_inf")
vx_snan = Test(vx, specifier=Test.IsSignalingNaN, likely=False, debug=debug_multi, tag="snan")
vx_inf = Test(vx, specifier=Test.IsInfty, likely=False, debug=debug_multi, tag="inf")
vx_subnormal = Test(vx, specifier=Test.IsSubnormal, likely=False, debug=debug_multi, tag="vx_subnormal")
# for x = m.2^e, such that e >= 0
#
# log(1+x) = log(1 + m.2^e)
# = log(2^e . 2^-e + m.2^e)
# = log(2^e . (2^-e + m))
# = log(2^e) + log(2^-e + m)
# = e . log(2) + log (2^-e + m)
#
# t = (2^-e + m)
# t = m_t . 2^e_t
# r ~ 1 / m_t => r.m_t ~ 1 ~ 0
#
# t' = t . 2^-e_t
# = 2^-e-e_t + m . 2^-e_t
#
# if e >= 0, then 2^-e <= 1, then 1 <= m + 2^-e <= 3
# r = m_r . 2^e_r
#
# log(1+x) = e.log(2) + log(r . 2^e_t . 2^-e_t . (2^-e + m) / r)
# = e.log(2) + log(r . 2^(-e-e_t) + r.m.2^-e_t) + e_t . log(2)- log(r)
# = (e+e_t).log(2) + log(r . t') - log(r)
# = (e+e_t).log(2) + log(r . t') - log(r)
# = (e+e_t).log(2) + P_log1p(r . t' - 1) - log(r)
#
#
# argument reduction
m = MantissaExtraction(vx, tag="vx", precision=self.precision, debug=debug_multi)
e = ExponentExtraction(vx, tag="e", precision=int_precision, debug=debug_multi)
# 2^-e
TwoMinusE = ExponentInsertion(-e, tag="Two_minus_e", precision=self.precision, debug=debug_multi)
t = Addition(TwoMinusE, m, precision=self.precision, tag="t", debug=debug_multi)
m_t = MantissaExtraction(t, tag="m_t", precision=self.precision, debug=debug_multi)
e_t = ExponentExtraction(t, tag="e_t", precision=int_precision, debug=debug_multi)
# 2^(-e-e_t)
TwoMinusEEt = ExponentInsertion(-e-e_t, tag="Two_minus_e_et", precision=self.precision)
TwoMinusEt = ExponentInsertion(-e_t, tag="Two_minus_et", precision=self.precision, debug=debug_multi)
rcp_mt = ReciprocalSeed(m_t, tag="rcp_mt", precision=self.precision, debug=debug_multi)
INDEX_SIZE = table_index_size
table_index = generic_mantissa_msb_index_fct(INDEX_SIZE, m_t)
table_index.set_attributes(tag="table_index", debug=debug_multi)
log_inv_lo = TableLoad(log_table, table_index, 1, tag="log_inv_lo", debug=debug_multi)
log_inv_hi = TableLoad(log_table, table_index, 0, tag="log_inv_hi", debug=debug_multi)
inv_err = S2**-6 # TODO: link to target DivisionSeed precision
Log.report(Log.Info, "building mathematical polynomial")
approx_interval = Interval(-inv_err, inv_err)
approx_fct = sollya.log1p(sollya.x) / (sollya.x)
poly_degree = sup(guessdegree(approx_fct, approx_interval, S2**-(self.precision.get_field_size()+1))) + 1
Log.report(Log.Debug, "poly_degree is {}", poly_degree)
global_poly_object = Polynomial.build_from_approximation(approx_fct, poly_degree, [self.precision]*(poly_degree+1), approx_interval, sollya.absolute)
poly_object = global_poly_object # .sub_poly(start_index=1)
EXT_PRECISION_MAP = {
ML_Binary32: ML_SingleSingle,
ML_Binary64: ML_DoubleDouble,
ML_SingleSingle: ML_TripleSingle,
ML_DoubleDouble: ML_TripleDouble
}
if not self.precision in EXT_PRECISION_MAP:
Log.report(Log.Error, "no extended precision available for {}", self.precision)
ext_precision = EXT_PRECISION_MAP[self.precision]
# pre_rtp = r . 2^(-e-e_t) + m .2^-e_t
pre_rtp = Addition(
rcp_mt * TwoMinusEEt,
Multiplication(
rcp_mt,
Multiplication(
m,
TwoMinusEt,
precision=self.precision,
tag="pre_mult",
debug=debug_multi,
),
precision=ext_precision,
tag="pre_mult2",
debug=debug_multi,
),
precision=ext_precision,
tag="pre_rtp",
debug=debug_multi
)
pre_red_vx = Addition(
pre_rtp,
-1,
precision=ext_precision,
)
red_vx = Conversion(pre_red_vx, precision=self.precision, tag="red_vx", debug=debug_multi)
Log.report(Log.Info, "generating polynomial evaluation scheme")
poly = PolynomialSchemeEvaluator.generate_horner_scheme(
poly_object, red_vx, unified_precision=self.precision)
poly.set_attributes(tag="poly", debug=debug_multi)
Log.report(Log.Debug, "{}", global_poly_object.get_sollya_object())
fp_e = Conversion(e + e_t, precision=self.precision, tag="fp_e", debug=debug_multi)
ext_poly = Multiplication(red_vx, poly, precision=ext_precision)
pre_result = Addition(
Addition(
fp_e * log2_hi,
fp_e * log2_lo,
precision=ext_precision
),
Addition(
Addition(
-log_inv_hi,
-log_inv_lo,
precision=ext_precision
),
ext_poly,
precision=ext_precision
),
precision=ext_precision
)
result = Conversion(pre_result, precision=self.precision, tag="result", debug=debug_multi)
# main scheme
Log.report(Log.Info, "MDL scheme")
pre_scheme = ConditionBlock(neg_input,
Statement(
ClearException(),
Raise(ML_FPE_Invalid),
Return(FP_QNaN(self.precision))
),
ConditionBlock(vx_nan_or_inf,
ConditionBlock(vx_inf,
Statement(
ClearException(),
Return(FP_PlusInfty(self.precision)),
),
Statement(
ClearException(),
ConditionBlock(vx_snan,
Raise(ML_FPE_Invalid)
),
Return(FP_QNaN(self.precision))
)
),
Return(result)
)
)
scheme = pre_scheme
return scheme
if __name__ == "__main__":
implem_results = []
for eps_target in [S2**-40, S2**-50, S2**-55, S2**-60, S2**-65]:
approx_interval = Interval(-S2**-5, S2**-5)
ctx = MLL_Context(ML_Binary64, approx_interval)
vx = Variable("x",
precision=ctx.variableFormat,
interval=approx_interval)
# guessding the best degree
poly_degree = int(
sup(
sollya.guessdegree(sollya.exp(sollya.x), approx_interval,
eps_target)))
# asking sollya to provide the approximation
poly_object = Polynomial.build_from_approximation(
sollya.exp(sollya.x), poly_degree,
[sollya.doubledouble] * (poly_degree + 1), vx.interval)
print("poly object is {}".format(poly_object))
poly_graph, poly_epsilon = mll_implementpoly_horner(
ctx, poly_object, eps_target, vx)
print("poly_graph is {}".format(
poly_graph.get_str(depth=None, display_precision=True)))
print("poly epsilon is {}".format(float(poly_epsilon)))
print("poly accuracy is {}".format(
get_accuracy_from_epsilon(poly_epsilon)))
implem_results.append(
(eps_target, poly_degree, poly_object, poly_graph, poly_epsilon))
for result in implem_results:
eps_target, poly_degree, poly_object, poly_graph, poly_epsilon = result
epsilon_log2 = int(sollya.floor(sollya.log2(poly_epsilon)))
def piecewise_approximation(function,
variable,
precision,
bound_low=-1.0,
bound_high=1.0,
num_intervals=16,
max_degree=2,
error_threshold=sollya.S2**-24):
""" To be documented """
# table to store coefficients of the approximation on each segment
coeff_table = ML_NewTable(dimensions=[num_intervals, max_degree + 1],
storage_precision=precision,
tag="coeff_table")
error_function = lambda p, f, ai, mod, t: sollya.dirtyinfnorm(p - f, ai)
max_approx_error = 0.0
interval_size = (bound_high - bound_low) / num_intervals
for i in range(num_intervals):
subint_low = bound_low + i * interval_size
subint_high = bound_low + (i + 1) * interval_size
#local_function = function(sollya.x)
#local_interval = Interval(subint_low, subint_high)
local_function = function(sollya.x + subint_low)
local_interval = Interval(-interval_size, interval_size)
local_degree = sollya.guessdegree(local_function, local_interval,
error_threshold)
degree = min(max_degree, local_degree)
if function(subint_low) == 0.0:
# if the lower bound is a zero to the function, we
# need to force value=0 for the constant coefficient
# and extend the approximation interval
degree_list = range(1, degree + 1)
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
function(sollya.x),
degree_list, [precision] * len(degree_list),
Interval(-subint_high, subint_high),
sollya.absolute,
error_function=error_function)
else:
try:
poly_object, approx_error = Polynomial.build_from_approximation_with_error(
local_function,
degree, [precision] * (degree + 1),
local_interval,
sollya.absolute,
error_function=error_function)
except SollyaError as err:
print("degree: {}".format(degree))
raise err
for ci in range(degree + 1):
if ci in poly_object.coeff_map:
coeff_table[i][ci] = poly_object.coeff_map[ci]
else:
coeff_table[i][ci] = 0.0
max_approx_error = max(max_approx_error, abs(approx_error))
# computing offset
diff = Subtraction(variable,
Constant(bound_low, precision=precision),
tag="diff",
precision=precision)
# delta = bound_high - bound_low
delta_ratio = Constant(num_intervals / (bound_high - bound_low),
precision=precision)
# computing table index
# index = nearestint(diff / delta * <num_intervals>)
index = Max(0,
Min(
NearestInteger(Multiplication(diff,
delta_ratio,
precision=precision),
precision=ML_Int32), num_intervals - 1),
tag="index",
debug=True,
precision=ML_Int32)
poly_var = Subtraction(diff,
Multiplication(
Conversion(index, precision=precision),
Constant(interval_size, precision=precision)),
precision=precision,
tag="poly_var",
debug=True)
# generating indexed polynomial
coeffs = [(ci, TableLoad(coeff_table, index, ci))
for ci in range(degree + 1)][::-1]
poly_scheme = PolynomialSchemeEvaluator.generate_horner_scheme2(
coeffs, poly_var, precision, {}, precision)
return poly_scheme, max_approx_error