
(FPCore (lo hi x) :precision binary64 (/ (- x lo) (- hi lo)))
double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = (x - lo) / (hi - lo)
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
def code(lo, hi, x): return (x - lo) / (hi - lo)
function code(lo, hi, x) return Float64(Float64(x - lo) / Float64(hi - lo)) end
function tmp = code(lo, hi, x) tmp = (x - lo) / (hi - lo); end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / N[(hi - lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi - lo}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (lo hi x) :precision binary64 (/ (- x lo) (- hi lo)))
double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = (x - lo) / (hi - lo)
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / (hi - lo);
}
def code(lo, hi, x): return (x - lo) / (hi - lo)
function code(lo, hi, x) return Float64(Float64(x - lo) / Float64(hi - lo)) end
function tmp = code(lo, hi, x) tmp = (x - lo) / (hi - lo); end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / N[(hi - lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi - lo}
\end{array}
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo))
(t_1 (pow t_0 2.0))
(t_2 (+ t_0 -1.0))
(t_3 (/ (fma hi t_2 x) lo)))
(if (<= hi 1.482e+308)
(/
(+ (pow (/ (+ x (- (* hi t_0) hi)) lo) 3.0) 1.0)
(+ t_1 (- 1.0 (/ (+ x (fabs (* hi t_2))) lo))))
(/ (+ 1.0 (pow t_3 3.0)) (- (+ 1.0 t_1) t_3)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double t_1 = pow(t_0, 2.0);
double t_2 = t_0 + -1.0;
double t_3 = fma(hi, t_2, x) / lo;
double tmp;
if (hi <= 1.482e+308) {
tmp = (pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (t_1 + (1.0 - ((x + fabs((hi * t_2))) / lo)));
} else {
tmp = (1.0 + pow(t_3, 3.0)) / ((1.0 + t_1) - t_3);
}
return tmp;
}
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) t_1 = t_0 ^ 2.0 t_2 = Float64(t_0 + -1.0) t_3 = Float64(fma(hi, t_2, x) / lo) tmp = 0.0 if (hi <= 1.482e+308) tmp = Float64(Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 3.0) + 1.0) / Float64(t_1 + Float64(1.0 - Float64(Float64(x + abs(Float64(hi * t_2))) / lo)))); else tmp = Float64(Float64(1.0 + (t_3 ^ 3.0)) / Float64(Float64(1.0 + t_1) - t_3)); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[Power[t$95$0, 2.0], $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + -1.0), $MachinePrecision]}, Block[{t$95$3 = N[(N[(hi * t$95$2 + x), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.482e+308], N[(N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] / N[(t$95$1 + N[(1.0 - N[(N[(x + N[Abs[N[(hi * t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[Power[t$95$3, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + t$95$1), $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
t_1 := {t\_0}^{2}\\
t_2 := t\_0 + -1\\
t_3 := \frac{\mathsf{fma}\left(hi, t\_2, x\right)}{lo}\\
\mathbf{if}\;hi \leq 1.482 \cdot 10^{+308}:\\
\;\;\;\;\frac{{\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{3} + 1}{t\_1 + \left(1 - \frac{x + \left|hi \cdot t\_2\right|}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + {t\_3}^{3}}{\left(1 + t\_1\right) - t\_3}\\
\end{array}
\end{array}
if hi < 1.482e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*18.7%
Simplified18.7%
+-commutative18.7%
flip3-+18.5%
Applied egg-rr17.9%
Taylor expanded in lo around inf 21.9%
neg-mul-121.9%
Simplified21.9%
add-sqr-sqrt5.5%
sqrt-unprod3.0%
pow23.0%
Applied egg-rr3.0%
unpow23.0%
rem-sqrt-square29.7%
sub-neg29.7%
+-commutative29.7%
neg-mul-129.7%
*-commutative29.7%
distribute-rgt-out29.7%
Simplified29.7%
if 1.482e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*7.2%
Simplified7.2%
+-commutative7.2%
flip3-+4.9%
Applied egg-rr4.9%
Taylor expanded in lo around inf 6.5%
neg-mul-16.5%
Simplified6.5%
*-un-lft-identity6.5%
Applied egg-rr20.8%
*-lft-identity20.8%
+-commutative20.8%
associate-+r-20.8%
+-commutative20.8%
Simplified20.8%
Final simplification26.3%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)))
(if (<= hi 1.5e+308)
(/
(+ (pow (/ (+ x (- (* hi t_0) hi)) lo) 3.0) 1.0)
(+ (pow t_0 2.0) (- 1.0 (/ (+ x (fabs (* hi (+ t_0 -1.0)))) lo))))
(+
(+ 1.0 (* hi (/ (- -1.0 (/ hi lo)) lo)))
(* x (+ (/ 1.0 lo) (/ hi (pow lo 2.0))))))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (pow(t_0, 2.0) + (1.0 - ((x + fabs((hi * (t_0 + -1.0)))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / pow(lo, 2.0))));
}
return tmp;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = (x - hi) / lo
if (hi <= 1.5d+308) then
tmp = ((((x + ((hi * t_0) - hi)) / lo) ** 3.0d0) + 1.0d0) / ((t_0 ** 2.0d0) + (1.0d0 - ((x + abs((hi * (t_0 + (-1.0d0))))) / lo)))
else
tmp = (1.0d0 + (hi * (((-1.0d0) - (hi / lo)) / lo))) + (x * ((1.0d0 / lo) + (hi / (lo ** 2.0d0))))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (Math.pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (Math.pow(t_0, 2.0) + (1.0 - ((x + Math.abs((hi * (t_0 + -1.0)))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / Math.pow(lo, 2.0))));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - hi) / lo tmp = 0 if hi <= 1.5e+308: tmp = (math.pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (math.pow(t_0, 2.0) + (1.0 - ((x + math.fabs((hi * (t_0 + -1.0)))) / lo))) else: tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / math.pow(lo, 2.0)))) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) tmp = 0.0 if (hi <= 1.5e+308) tmp = Float64(Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 3.0) + 1.0) / Float64((t_0 ^ 2.0) + Float64(1.0 - Float64(Float64(x + abs(Float64(hi * Float64(t_0 + -1.0)))) / lo)))); else tmp = Float64(Float64(1.0 + Float64(hi * Float64(Float64(-1.0 - Float64(hi / lo)) / lo))) + Float64(x * Float64(Float64(1.0 / lo) + Float64(hi / (lo ^ 2.0))))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - hi) / lo; tmp = 0.0; if (hi <= 1.5e+308) tmp = ((((x + ((hi * t_0) - hi)) / lo) ^ 3.0) + 1.0) / ((t_0 ^ 2.0) + (1.0 - ((x + abs((hi * (t_0 + -1.0)))) / lo))); else tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / (lo ^ 2.0)))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.5e+308], N[(N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] / N[(N[Power[t$95$0, 2.0], $MachinePrecision] + N[(1.0 - N[(N[(x + N[Abs[N[(hi * N[(t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(hi * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(1.0 / lo), $MachinePrecision] + N[(hi / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
\mathbf{if}\;hi \leq 1.5 \cdot 10^{+308}:\\
\;\;\;\;\frac{{\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{3} + 1}{{t\_0}^{2} + \left(1 - \frac{x + \left|hi \cdot \left(t\_0 + -1\right)\right|}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + hi \cdot \frac{-1 - \frac{hi}{lo}}{lo}\right) + x \cdot \left(\frac{1}{lo} + \frac{hi}{{lo}^{2}}\right)\\
\end{array}
\end{array}
if hi < 1.5e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*18.6%
Simplified18.6%
+-commutative18.6%
flip3-+18.5%
Applied egg-rr17.9%
Taylor expanded in lo around inf 21.9%
neg-mul-121.9%
Simplified21.9%
add-sqr-sqrt6.0%
sqrt-unprod3.0%
pow23.0%
Applied egg-rr3.0%
unpow23.0%
rem-sqrt-square29.5%
sub-neg29.5%
+-commutative29.5%
neg-mul-129.5%
*-commutative29.5%
distribute-rgt-out29.5%
Simplified29.5%
if 1.5e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*6.7%
Simplified6.7%
expm1-log1p-u6.7%
expm1-undefine6.7%
add-sqr-sqrt4.4%
sqrt-unprod6.6%
sqr-neg6.6%
sqrt-unprod2.2%
add-sqr-sqrt4.3%
Applied egg-rr4.3%
expm1-define4.3%
associate-+r-4.3%
div-sub4.3%
associate-*r/0.0%
div-sub0.0%
associate-*r/4.3%
associate-+r-4.3%
fma-neg19.5%
Simplified19.5%
Taylor expanded in hi around 0 19.5%
sub-neg19.5%
mul-1-neg19.5%
+-commutative19.5%
sub-neg19.5%
div-sub19.5%
metadata-eval19.5%
Simplified19.5%
Taylor expanded in x around 0 19.5%
associate-+r+19.5%
mul-1-neg19.5%
associate-/l*19.5%
distribute-rgt-neg-in19.5%
mul-1-neg19.5%
associate-*r/19.5%
distribute-lft-in19.5%
metadata-eval19.5%
mul-1-neg19.5%
unsub-neg19.5%
Simplified19.5%
Final simplification25.9%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (+ x (- (* hi (/ (- x hi) lo)) hi)) lo)))
(if (<= hi 1.5e+308)
(/
(+ (pow t_0 3.0) 1.0)
(+ (pow t_0 2.0) (- 1.0 (/ (+ x (* (- x hi) (/ hi lo))) lo))))
(+
(+ 1.0 (* hi (/ (- -1.0 (/ hi lo)) lo)))
(* x (+ (/ 1.0 lo) (/ hi (pow lo 2.0))))))))
double code(double lo, double hi, double x) {
double t_0 = (x + ((hi * ((x - hi) / lo)) - hi)) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (pow(t_0, 3.0) + 1.0) / (pow(t_0, 2.0) + (1.0 - ((x + ((x - hi) * (hi / lo))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / pow(lo, 2.0))));
}
return tmp;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = (x + ((hi * ((x - hi) / lo)) - hi)) / lo
if (hi <= 1.5d+308) then
tmp = ((t_0 ** 3.0d0) + 1.0d0) / ((t_0 ** 2.0d0) + (1.0d0 - ((x + ((x - hi) * (hi / lo))) / lo)))
else
tmp = (1.0d0 + (hi * (((-1.0d0) - (hi / lo)) / lo))) + (x * ((1.0d0 / lo) + (hi / (lo ** 2.0d0))))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x + ((hi * ((x - hi) / lo)) - hi)) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (Math.pow(t_0, 3.0) + 1.0) / (Math.pow(t_0, 2.0) + (1.0 - ((x + ((x - hi) * (hi / lo))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / Math.pow(lo, 2.0))));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x + ((hi * ((x - hi) / lo)) - hi)) / lo tmp = 0 if hi <= 1.5e+308: tmp = (math.pow(t_0, 3.0) + 1.0) / (math.pow(t_0, 2.0) + (1.0 - ((x + ((x - hi) * (hi / lo))) / lo))) else: tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / math.pow(lo, 2.0)))) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x + Float64(Float64(hi * Float64(Float64(x - hi) / lo)) - hi)) / lo) tmp = 0.0 if (hi <= 1.5e+308) tmp = Float64(Float64((t_0 ^ 3.0) + 1.0) / Float64((t_0 ^ 2.0) + Float64(1.0 - Float64(Float64(x + Float64(Float64(x - hi) * Float64(hi / lo))) / lo)))); else tmp = Float64(Float64(1.0 + Float64(hi * Float64(Float64(-1.0 - Float64(hi / lo)) / lo))) + Float64(x * Float64(Float64(1.0 / lo) + Float64(hi / (lo ^ 2.0))))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x + ((hi * ((x - hi) / lo)) - hi)) / lo; tmp = 0.0; if (hi <= 1.5e+308) tmp = ((t_0 ^ 3.0) + 1.0) / ((t_0 ^ 2.0) + (1.0 - ((x + ((x - hi) * (hi / lo))) / lo))); else tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / (lo ^ 2.0)))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x + N[(N[(hi * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.5e+308], N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + 1.0), $MachinePrecision] / N[(N[Power[t$95$0, 2.0], $MachinePrecision] + N[(1.0 - N[(N[(x + N[(N[(x - hi), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(hi * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(1.0 / lo), $MachinePrecision] + N[(hi / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x + \left(hi \cdot \frac{x - hi}{lo} - hi\right)}{lo}\\
\mathbf{if}\;hi \leq 1.5 \cdot 10^{+308}:\\
\;\;\;\;\frac{{t\_0}^{3} + 1}{{t\_0}^{2} + \left(1 - \frac{x + \left(x - hi\right) \cdot \frac{hi}{lo}}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + hi \cdot \frac{-1 - \frac{hi}{lo}}{lo}\right) + x \cdot \left(\frac{1}{lo} + \frac{hi}{{lo}^{2}}\right)\\
\end{array}
\end{array}
if hi < 1.5e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*18.6%
Simplified18.6%
+-commutative18.6%
flip3-+18.5%
Applied egg-rr17.9%
Taylor expanded in lo around 0 3.0%
associate-*r/23.5%
div-sub23.5%
sub-neg23.5%
mul-1-neg23.5%
distribute-lft-in23.5%
associate-/l*13.4%
*-commutative13.4%
associate-*r/23.5%
associate-*r*23.5%
*-commutative23.5%
neg-mul-123.5%
distribute-rgt-in23.5%
sub-neg23.5%
Simplified23.5%
if 1.5e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*6.7%
Simplified6.7%
expm1-log1p-u6.7%
expm1-undefine6.7%
add-sqr-sqrt4.4%
sqrt-unprod6.6%
sqr-neg6.6%
sqrt-unprod2.2%
add-sqr-sqrt4.3%
Applied egg-rr4.3%
expm1-define4.3%
associate-+r-4.3%
div-sub4.3%
associate-*r/0.0%
div-sub0.0%
associate-*r/4.3%
associate-+r-4.3%
fma-neg19.5%
Simplified19.5%
Taylor expanded in hi around 0 19.5%
sub-neg19.5%
mul-1-neg19.5%
+-commutative19.5%
sub-neg19.5%
div-sub19.5%
metadata-eval19.5%
Simplified19.5%
Taylor expanded in x around 0 19.5%
associate-+r+19.5%
mul-1-neg19.5%
associate-/l*19.5%
distribute-rgt-neg-in19.5%
mul-1-neg19.5%
associate-*r/19.5%
distribute-lft-in19.5%
metadata-eval19.5%
mul-1-neg19.5%
unsub-neg19.5%
Simplified19.5%
Final simplification22.1%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)))
(if (<= hi 1.5e+308)
(/
(+ (pow (/ (+ x (- (* hi t_0) hi)) lo) 3.0) 1.0)
(+ (pow t_0 2.0) (- 1.0 (/ (+ x (* x (/ hi lo))) lo))))
(+
(+ 1.0 (* hi (/ (- -1.0 (/ hi lo)) lo)))
(* x (+ (/ 1.0 lo) (/ hi (pow lo 2.0))))))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (pow(t_0, 2.0) + (1.0 - ((x + (x * (hi / lo))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / pow(lo, 2.0))));
}
return tmp;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = (x - hi) / lo
if (hi <= 1.5d+308) then
tmp = ((((x + ((hi * t_0) - hi)) / lo) ** 3.0d0) + 1.0d0) / ((t_0 ** 2.0d0) + (1.0d0 - ((x + (x * (hi / lo))) / lo)))
else
tmp = (1.0d0 + (hi * (((-1.0d0) - (hi / lo)) / lo))) + (x * ((1.0d0 / lo) + (hi / (lo ** 2.0d0))))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (Math.pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (Math.pow(t_0, 2.0) + (1.0 - ((x + (x * (hi / lo))) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / Math.pow(lo, 2.0))));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - hi) / lo tmp = 0 if hi <= 1.5e+308: tmp = (math.pow(((x + ((hi * t_0) - hi)) / lo), 3.0) + 1.0) / (math.pow(t_0, 2.0) + (1.0 - ((x + (x * (hi / lo))) / lo))) else: tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / math.pow(lo, 2.0)))) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) tmp = 0.0 if (hi <= 1.5e+308) tmp = Float64(Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 3.0) + 1.0) / Float64((t_0 ^ 2.0) + Float64(1.0 - Float64(Float64(x + Float64(x * Float64(hi / lo))) / lo)))); else tmp = Float64(Float64(1.0 + Float64(hi * Float64(Float64(-1.0 - Float64(hi / lo)) / lo))) + Float64(x * Float64(Float64(1.0 / lo) + Float64(hi / (lo ^ 2.0))))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - hi) / lo; tmp = 0.0; if (hi <= 1.5e+308) tmp = ((((x + ((hi * t_0) - hi)) / lo) ^ 3.0) + 1.0) / ((t_0 ^ 2.0) + (1.0 - ((x + (x * (hi / lo))) / lo))); else tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / (lo ^ 2.0)))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.5e+308], N[(N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] / N[(N[Power[t$95$0, 2.0], $MachinePrecision] + N[(1.0 - N[(N[(x + N[(x * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(hi * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(1.0 / lo), $MachinePrecision] + N[(hi / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
\mathbf{if}\;hi \leq 1.5 \cdot 10^{+308}:\\
\;\;\;\;\frac{{\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{3} + 1}{{t\_0}^{2} + \left(1 - \frac{x + x \cdot \frac{hi}{lo}}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + hi \cdot \frac{-1 - \frac{hi}{lo}}{lo}\right) + x \cdot \left(\frac{1}{lo} + \frac{hi}{{lo}^{2}}\right)\\
\end{array}
\end{array}
if hi < 1.5e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*18.6%
Simplified18.6%
+-commutative18.6%
flip3-+18.5%
Applied egg-rr17.9%
Taylor expanded in lo around inf 21.9%
neg-mul-121.9%
Simplified21.9%
Taylor expanded in x around inf 13.3%
*-commutative13.3%
associate-*r/23.5%
Simplified23.5%
if 1.5e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*6.7%
Simplified6.7%
expm1-log1p-u6.7%
expm1-undefine6.7%
add-sqr-sqrt4.4%
sqrt-unprod6.6%
sqr-neg6.6%
sqrt-unprod2.2%
add-sqr-sqrt4.3%
Applied egg-rr4.3%
expm1-define4.3%
associate-+r-4.3%
div-sub4.3%
associate-*r/0.0%
div-sub0.0%
associate-*r/4.3%
associate-+r-4.3%
fma-neg19.5%
Simplified19.5%
Taylor expanded in hi around 0 19.5%
sub-neg19.5%
mul-1-neg19.5%
+-commutative19.5%
sub-neg19.5%
div-sub19.5%
metadata-eval19.5%
Simplified19.5%
Taylor expanded in x around 0 19.5%
associate-+r+19.5%
mul-1-neg19.5%
associate-/l*19.5%
distribute-rgt-neg-in19.5%
mul-1-neg19.5%
associate-*r/19.5%
distribute-lft-in19.5%
metadata-eval19.5%
mul-1-neg19.5%
unsub-neg19.5%
Simplified19.5%
Final simplification22.0%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- hi x) lo)))
(if (<= hi 1.5e+308)
(/
(+ (pow (/ (+ x (- (* hi (/ (- x hi) lo)) hi)) lo) 3.0) 1.0)
(+ (* t_0 t_0) (+ 1.0 (/ (- (+ hi (* hi t_0)) x) lo))))
(+
(+ 1.0 (* hi (/ (- -1.0 (/ hi lo)) lo)))
(* x (+ (/ 1.0 lo) (/ hi (pow lo 2.0))))))))
double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (pow(((x + ((hi * ((x - hi) / lo)) - hi)) / lo), 3.0) + 1.0) / ((t_0 * t_0) + (1.0 + (((hi + (hi * t_0)) - x) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / pow(lo, 2.0))));
}
return tmp;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = (hi - x) / lo
if (hi <= 1.5d+308) then
tmp = ((((x + ((hi * ((x - hi) / lo)) - hi)) / lo) ** 3.0d0) + 1.0d0) / ((t_0 * t_0) + (1.0d0 + (((hi + (hi * t_0)) - x) / lo)))
else
tmp = (1.0d0 + (hi * (((-1.0d0) - (hi / lo)) / lo))) + (x * ((1.0d0 / lo) + (hi / (lo ** 2.0d0))))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double tmp;
if (hi <= 1.5e+308) {
tmp = (Math.pow(((x + ((hi * ((x - hi) / lo)) - hi)) / lo), 3.0) + 1.0) / ((t_0 * t_0) + (1.0 + (((hi + (hi * t_0)) - x) / lo)));
} else {
tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / Math.pow(lo, 2.0))));
}
return tmp;
}
def code(lo, hi, x): t_0 = (hi - x) / lo tmp = 0 if hi <= 1.5e+308: tmp = (math.pow(((x + ((hi * ((x - hi) / lo)) - hi)) / lo), 3.0) + 1.0) / ((t_0 * t_0) + (1.0 + (((hi + (hi * t_0)) - x) / lo))) else: tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / math.pow(lo, 2.0)))) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(hi - x) / lo) tmp = 0.0 if (hi <= 1.5e+308) tmp = Float64(Float64((Float64(Float64(x + Float64(Float64(hi * Float64(Float64(x - hi) / lo)) - hi)) / lo) ^ 3.0) + 1.0) / Float64(Float64(t_0 * t_0) + Float64(1.0 + Float64(Float64(Float64(hi + Float64(hi * t_0)) - x) / lo)))); else tmp = Float64(Float64(1.0 + Float64(hi * Float64(Float64(-1.0 - Float64(hi / lo)) / lo))) + Float64(x * Float64(Float64(1.0 / lo) + Float64(hi / (lo ^ 2.0))))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (hi - x) / lo; tmp = 0.0; if (hi <= 1.5e+308) tmp = ((((x + ((hi * ((x - hi) / lo)) - hi)) / lo) ^ 3.0) + 1.0) / ((t_0 * t_0) + (1.0 + (((hi + (hi * t_0)) - x) / lo))); else tmp = (1.0 + (hi * ((-1.0 - (hi / lo)) / lo))) + (x * ((1.0 / lo) + (hi / (lo ^ 2.0)))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.5e+308], N[(N[(N[Power[N[(N[(x + N[(N[(hi * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision] + 1.0), $MachinePrecision] / N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(1.0 + N[(N[(N[(hi + N[(hi * t$95$0), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(hi * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(1.0 / lo), $MachinePrecision] + N[(hi / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi - x}{lo}\\
\mathbf{if}\;hi \leq 1.5 \cdot 10^{+308}:\\
\;\;\;\;\frac{{\left(\frac{x + \left(hi \cdot \frac{x - hi}{lo} - hi\right)}{lo}\right)}^{3} + 1}{t\_0 \cdot t\_0 + \left(1 + \frac{\left(hi + hi \cdot t\_0\right) - x}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + hi \cdot \frac{-1 - \frac{hi}{lo}}{lo}\right) + x \cdot \left(\frac{1}{lo} + \frac{hi}{{lo}^{2}}\right)\\
\end{array}
\end{array}
if hi < 1.5e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*18.6%
Simplified18.6%
+-commutative18.6%
flip3-+18.5%
Applied egg-rr17.9%
Taylor expanded in lo around inf 21.9%
neg-mul-121.9%
Simplified21.9%
sub-neg21.9%
pow221.9%
Applied egg-rr21.9%
if 1.5e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*6.7%
Simplified6.7%
expm1-log1p-u6.7%
expm1-undefine6.7%
add-sqr-sqrt4.4%
sqrt-unprod6.6%
sqr-neg6.6%
sqrt-unprod2.2%
add-sqr-sqrt4.3%
Applied egg-rr4.3%
expm1-define4.3%
associate-+r-4.3%
div-sub4.3%
associate-*r/0.0%
div-sub0.0%
associate-*r/4.3%
associate-+r-4.3%
fma-neg19.5%
Simplified19.5%
Taylor expanded in hi around 0 19.5%
sub-neg19.5%
mul-1-neg19.5%
+-commutative19.5%
sub-neg19.5%
div-sub19.5%
metadata-eval19.5%
Simplified19.5%
Taylor expanded in x around 0 19.5%
associate-+r+19.5%
mul-1-neg19.5%
associate-/l*19.5%
distribute-rgt-neg-in19.5%
mul-1-neg19.5%
associate-*r/19.5%
distribute-lft-in19.5%
metadata-eval19.5%
mul-1-neg19.5%
unsub-neg19.5%
Simplified19.5%
Final simplification21.0%
(FPCore (lo hi x) :precision binary64 (- 1.0 (/ (- (* hi (- (- (/ hi lo) (/ x lo)) -1.0)) x) lo)))
double code(double lo, double hi, double x) {
return 1.0 - (((hi * (((hi / lo) - (x / lo)) - -1.0)) - x) / lo);
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0 - (((hi * (((hi / lo) - (x / lo)) - (-1.0d0))) - x) / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 - (((hi * (((hi / lo) - (x / lo)) - -1.0)) - x) / lo);
}
def code(lo, hi, x): return 1.0 - (((hi * (((hi / lo) - (x / lo)) - -1.0)) - x) / lo)
function code(lo, hi, x) return Float64(1.0 - Float64(Float64(Float64(hi * Float64(Float64(Float64(hi / lo) - Float64(x / lo)) - -1.0)) - x) / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 - (((hi * (((hi / lo) - (x / lo)) - -1.0)) - x) / lo); end
code[lo_, hi_, x_] := N[(1.0 - N[(N[(N[(hi * N[(N[(N[(hi / lo), $MachinePrecision] - N[(x / lo), $MachinePrecision]), $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \frac{hi \cdot \left(\left(\frac{hi}{lo} - \frac{x}{lo}\right) - -1\right) - x}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*14.3%
Simplified14.3%
expm1-log1p-u14.3%
expm1-undefine14.3%
add-sqr-sqrt4.8%
sqrt-unprod13.8%
sqr-neg13.8%
sqrt-unprod9.0%
add-sqr-sqrt13.0%
Applied egg-rr13.0%
expm1-define13.0%
associate-+r-12.9%
div-sub12.9%
associate-*r/0.0%
div-sub0.0%
associate-*r/12.9%
associate-+r-13.0%
fma-neg19.1%
Simplified19.1%
Taylor expanded in lo around -inf 0.7%
mul-1-neg0.7%
distribute-lft-out0.7%
associate-/l*13.2%
Simplified13.2%
Taylor expanded in hi around 0 19.1%
Final simplification19.1%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* hi (/ (- -1.0 (/ hi lo)) lo))))
double code(double lo, double hi, double x) {
return 1.0 + (hi * ((-1.0 - (hi / lo)) / lo));
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0 + (hi * (((-1.0d0) - (hi / lo)) / lo))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (hi * ((-1.0 - (hi / lo)) / lo));
}
def code(lo, hi, x): return 1.0 + (hi * ((-1.0 - (hi / lo)) / lo))
function code(lo, hi, x) return Float64(1.0 + Float64(hi * Float64(Float64(-1.0 - Float64(hi / lo)) / lo))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (hi * ((-1.0 - (hi / lo)) / lo)); end
code[lo_, hi_, x_] := N[(1.0 + N[(hi * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + hi \cdot \frac{-1 - \frac{hi}{lo}}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*14.3%
Simplified14.3%
expm1-log1p-u14.3%
expm1-undefine14.3%
add-sqr-sqrt4.8%
sqrt-unprod13.8%
sqr-neg13.8%
sqrt-unprod9.0%
add-sqr-sqrt13.0%
Applied egg-rr13.0%
expm1-define13.0%
associate-+r-12.9%
div-sub12.9%
associate-*r/0.0%
div-sub0.0%
associate-*r/12.9%
associate-+r-13.0%
fma-neg19.1%
Simplified19.1%
Taylor expanded in hi around 0 19.1%
sub-neg19.1%
mul-1-neg19.1%
+-commutative19.1%
sub-neg19.1%
div-sub19.1%
metadata-eval19.1%
Simplified19.1%
Taylor expanded in x around 0 19.1%
mul-1-neg19.1%
associate-/l*19.1%
distribute-rgt-neg-in19.1%
mul-1-neg19.1%
associate-*r/19.1%
distribute-lft-in19.1%
metadata-eval19.1%
mul-1-neg19.1%
unsub-neg19.1%
Simplified19.1%
(FPCore (lo hi x) :precision binary64 (/ lo (- hi)))
double code(double lo, double hi, double x) {
return lo / -hi;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = lo / -hi
end function
public static double code(double lo, double hi, double x) {
return lo / -hi;
}
def code(lo, hi, x): return lo / -hi
function code(lo, hi, x) return Float64(lo / Float64(-hi)) end
function tmp = code(lo, hi, x) tmp = lo / -hi; end
code[lo_, hi_, x_] := N[(lo / (-hi)), $MachinePrecision]
\begin{array}{l}
\\
\frac{lo}{-hi}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
Taylor expanded in x around 0 18.8%
neg-mul-118.8%
distribute-neg-frac18.8%
Simplified18.8%
Final simplification18.8%
(FPCore (lo hi x) :precision binary64 1.0)
double code(double lo, double hi, double x) {
return 1.0;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = 1.0d0
end function
public static double code(double lo, double hi, double x) {
return 1.0;
}
def code(lo, hi, x): return 1.0
function code(lo, hi, x) return 1.0 end
function tmp = code(lo, hi, x) tmp = 1.0; end
code[lo_, hi_, x_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 18.7%
herbie shell --seed 2024110
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))