
(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 10 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 (fma hi (/ (+ hi x) lo) hi)) lo)))
(if (<= hi 1.445e+308)
(/
(+ 1.0 (+ 1.0 (+ (pow t_0 3.0) -1.0)))
(+
1.0
(+
(pow (/ (+ x (- (* hi (/ (- x hi) lo)) hi)) lo) 2.0)
(/ (- (* hi (/ (- hi x) lo)) x) lo))))
(sqrt (pow (/ (- 1.0 (pow t_0 2.0)) (+ 1.0 t_0)) 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x + fma(hi, ((hi + x) / lo), hi)) / lo;
double tmp;
if (hi <= 1.445e+308) {
tmp = (1.0 + (1.0 + (pow(t_0, 3.0) + -1.0))) / (1.0 + (pow(((x + ((hi * ((x - hi) / lo)) - hi)) / lo), 2.0) + (((hi * ((hi - x) / lo)) - x) / lo)));
} else {
tmp = sqrt(pow(((1.0 - pow(t_0, 2.0)) / (1.0 + t_0)), 2.0));
}
return tmp;
}
function code(lo, hi, x) t_0 = Float64(Float64(x + fma(hi, Float64(Float64(hi + x) / lo), hi)) / lo) tmp = 0.0 if (hi <= 1.445e+308) tmp = Float64(Float64(1.0 + Float64(1.0 + Float64((t_0 ^ 3.0) + -1.0))) / Float64(1.0 + Float64((Float64(Float64(x + Float64(Float64(hi * Float64(Float64(x - hi) / lo)) - hi)) / lo) ^ 2.0) + Float64(Float64(Float64(hi * Float64(Float64(hi - x) / lo)) - x) / lo)))); else tmp = sqrt((Float64(Float64(1.0 - (t_0 ^ 2.0)) / Float64(1.0 + t_0)) ^ 2.0)); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x + N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.445e+308], N[(N[(1.0 + N[(1.0 + N[(N[Power[t$95$0, 3.0], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[Power[N[(N[(x + N[(N[(hi * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[(N[(hi * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[Power[N[(N[(1.0 - N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x + \mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi\right)}{lo}\\
\mathbf{if}\;hi \leq 1.445 \cdot 10^{+308}:\\
\;\;\;\;\frac{1 + \left(1 + \left({t\_0}^{3} + -1\right)\right)}{1 + \left({\left(\frac{x + \left(hi \cdot \frac{x - hi}{lo} - hi\right)}{lo}\right)}^{2} + \frac{hi \cdot \frac{hi - x}{lo} - x}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{\left(\frac{1 - {t\_0}^{2}}{1 + t\_0}\right)}^{2}}\\
\end{array}
\end{array}
if hi < 1.445e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*19.1%
Simplified19.1%
flip3-+19.0%
Applied egg-rr18.3%
Taylor expanded in lo around 0 3.0%
associate-*r/23.8%
Simplified23.8%
expm1-log1p-u23.8%
log1p-define23.8%
expm1-undefine23.8%
Applied egg-rr24.1%
associate--l+24.1%
+-commutative24.1%
Simplified24.1%
if 1.445e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*9.0%
Simplified9.0%
add-sqr-sqrt9.0%
sqrt-unprod9.0%
pow29.0%
add-sqr-sqrt5.1%
sqrt-unprod9.0%
sqr-neg9.0%
sqrt-unprod3.9%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
fmm-def19.9%
Simplified19.9%
Applied egg-rr19.9%
Final simplification22.3%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)))
(if (<= hi 1.445e+308)
(/
(+
1.0
(+ 1.0 (+ (pow (/ (+ x (fma hi (/ (+ hi x) lo) hi)) lo) 3.0) -1.0)))
(+
1.0
(+
(pow (/ (+ x (- (* hi t_0) hi)) lo) 2.0)
(/ (- (* hi (/ (- hi x) lo)) x) lo))))
(sqrt (pow (+ 1.0 (/ (+ x (* hi (+ t_0 -1.0))) lo)) 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.445e+308) {
tmp = (1.0 + (1.0 + (pow(((x + fma(hi, ((hi + x) / lo), hi)) / lo), 3.0) + -1.0))) / (1.0 + (pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + (((hi * ((hi - x) / lo)) - x) / lo)));
} else {
tmp = sqrt(pow((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)), 2.0));
}
return tmp;
}
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) tmp = 0.0 if (hi <= 1.445e+308) tmp = Float64(Float64(1.0 + Float64(1.0 + Float64((Float64(Float64(x + fma(hi, Float64(Float64(hi + x) / lo), hi)) / lo) ^ 3.0) + -1.0))) / Float64(1.0 + Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 2.0) + Float64(Float64(Float64(hi * Float64(Float64(hi - x) / lo)) - x) / lo)))); else tmp = sqrt((Float64(1.0 + Float64(Float64(x + Float64(hi * Float64(t_0 + -1.0))) / lo)) ^ 2.0)); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.445e+308], N[(N[(1.0 + N[(1.0 + N[(N[Power[N[(N[(x + N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[(N[(hi * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[(hi * N[(t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
\mathbf{if}\;hi \leq 1.445 \cdot 10^{+308}:\\
\;\;\;\;\frac{1 + \left(1 + \left({\left(\frac{x + \mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi\right)}{lo}\right)}^{3} + -1\right)\right)}{1 + \left({\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{2} + \frac{hi \cdot \frac{hi - x}{lo} - x}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{\left(1 + \frac{x + hi \cdot \left(t\_0 + -1\right)}{lo}\right)}^{2}}\\
\end{array}
\end{array}
if hi < 1.445e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*19.1%
Simplified19.1%
flip3-+19.0%
Applied egg-rr18.3%
Taylor expanded in lo around 0 3.0%
associate-*r/23.8%
Simplified23.8%
expm1-log1p-u23.8%
log1p-define23.8%
expm1-undefine23.8%
Applied egg-rr24.1%
associate--l+24.1%
+-commutative24.1%
Simplified24.1%
if 1.445e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*9.0%
Simplified9.0%
add-sqr-sqrt9.0%
sqrt-unprod9.0%
pow29.0%
add-sqr-sqrt5.1%
sqrt-unprod9.0%
sqr-neg9.0%
sqrt-unprod3.9%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
fmm-def19.9%
Simplified19.9%
Taylor expanded in hi around 0 19.9%
sub-neg19.9%
mul-1-neg19.9%
+-commutative19.9%
sub-neg19.9%
div-sub19.9%
metadata-eval19.9%
Simplified19.9%
Final simplification22.3%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)) (t_1 (* hi (/ (- hi x) lo))))
(if (<= hi 1.445e+308)
(/
(+ 1.0 (pow (/ (- (+ hi t_1) x) lo) 3.0))
(+ 1.0 (+ (pow (/ (+ x (- (* hi t_0) hi)) lo) 2.0) (/ (- t_1 x) lo))))
(sqrt (pow (+ 1.0 (/ (+ x (* hi (+ t_0 -1.0))) lo)) 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double t_1 = hi * ((hi - x) / lo);
double tmp;
if (hi <= 1.445e+308) {
tmp = (1.0 + pow((((hi + t_1) - x) / lo), 3.0)) / (1.0 + (pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + ((t_1 - x) / lo)));
} else {
tmp = sqrt(pow((1.0 + ((x + (hi * (t_0 + -1.0))) / 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) :: t_1
real(8) :: tmp
t_0 = (x - hi) / lo
t_1 = hi * ((hi - x) / lo)
if (hi <= 1.445d+308) then
tmp = (1.0d0 + ((((hi + t_1) - x) / lo) ** 3.0d0)) / (1.0d0 + ((((x + ((hi * t_0) - hi)) / lo) ** 2.0d0) + ((t_1 - x) / lo)))
else
tmp = sqrt(((1.0d0 + ((x + (hi * (t_0 + (-1.0d0)))) / 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 t_1 = hi * ((hi - x) / lo);
double tmp;
if (hi <= 1.445e+308) {
tmp = (1.0 + Math.pow((((hi + t_1) - x) / lo), 3.0)) / (1.0 + (Math.pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + ((t_1 - x) / lo)));
} else {
tmp = Math.sqrt(Math.pow((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)), 2.0));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - hi) / lo t_1 = hi * ((hi - x) / lo) tmp = 0 if hi <= 1.445e+308: tmp = (1.0 + math.pow((((hi + t_1) - x) / lo), 3.0)) / (1.0 + (math.pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + ((t_1 - x) / lo))) else: tmp = math.sqrt(math.pow((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)), 2.0)) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) t_1 = Float64(hi * Float64(Float64(hi - x) / lo)) tmp = 0.0 if (hi <= 1.445e+308) tmp = Float64(Float64(1.0 + (Float64(Float64(Float64(hi + t_1) - x) / lo) ^ 3.0)) / Float64(1.0 + Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 2.0) + Float64(Float64(t_1 - x) / lo)))); else tmp = sqrt((Float64(1.0 + Float64(Float64(x + Float64(hi * Float64(t_0 + -1.0))) / lo)) ^ 2.0)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - hi) / lo; t_1 = hi * ((hi - x) / lo); tmp = 0.0; if (hi <= 1.445e+308) tmp = (1.0 + ((((hi + t_1) - x) / lo) ^ 3.0)) / (1.0 + ((((x + ((hi * t_0) - hi)) / lo) ^ 2.0) + ((t_1 - x) / lo))); else tmp = sqrt(((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)) ^ 2.0)); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(hi * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[hi, 1.445e+308], N[(N[(1.0 + N[Power[N[(N[(N[(hi + t$95$1), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[(t$95$1 - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[(hi * N[(t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
t_1 := hi \cdot \frac{hi - x}{lo}\\
\mathbf{if}\;hi \leq 1.445 \cdot 10^{+308}:\\
\;\;\;\;\frac{1 + {\left(\frac{\left(hi + t\_1\right) - x}{lo}\right)}^{3}}{1 + \left({\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{2} + \frac{t\_1 - x}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{\left(1 + \frac{x + hi \cdot \left(t\_0 + -1\right)}{lo}\right)}^{2}}\\
\end{array}
\end{array}
if hi < 1.445e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*19.1%
Simplified19.1%
flip3-+19.0%
Applied egg-rr18.3%
Taylor expanded in lo around 0 3.0%
associate-*r/23.8%
Simplified23.8%
add-sqr-sqrt14.1%
sqrt-unprod19.3%
sqr-neg19.3%
sqrt-unprod5.2%
add-sqr-sqrt18.3%
Applied egg-rr24.0%
if 1.445e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*9.0%
Simplified9.0%
add-sqr-sqrt9.0%
sqrt-unprod9.0%
pow29.0%
add-sqr-sqrt5.1%
sqrt-unprod9.0%
sqr-neg9.0%
sqrt-unprod3.9%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
fmm-def19.9%
Simplified19.9%
Taylor expanded in hi around 0 19.9%
sub-neg19.9%
mul-1-neg19.9%
+-commutative19.9%
sub-neg19.9%
div-sub19.9%
metadata-eval19.9%
Simplified19.9%
Final simplification22.2%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)))
(if (<= hi 1.445e+308)
(/
(+ 1.0 (pow (/ x lo) 3.0))
(+
1.0
(+
(pow (/ (+ x (- (* hi t_0) hi)) lo) 2.0)
(/ (- (* hi (/ (- hi x) lo)) x) lo))))
(sqrt (pow (+ 1.0 (/ (+ x (* hi (+ t_0 -1.0))) lo)) 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.445e+308) {
tmp = (1.0 + pow((x / lo), 3.0)) / (1.0 + (pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + (((hi * ((hi - x) / lo)) - x) / lo)));
} else {
tmp = sqrt(pow((1.0 + ((x + (hi * (t_0 + -1.0))) / 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.445d+308) then
tmp = (1.0d0 + ((x / lo) ** 3.0d0)) / (1.0d0 + ((((x + ((hi * t_0) - hi)) / lo) ** 2.0d0) + (((hi * ((hi - x) / lo)) - x) / lo)))
else
tmp = sqrt(((1.0d0 + ((x + (hi * (t_0 + (-1.0d0)))) / 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.445e+308) {
tmp = (1.0 + Math.pow((x / lo), 3.0)) / (1.0 + (Math.pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + (((hi * ((hi - x) / lo)) - x) / lo)));
} else {
tmp = Math.sqrt(Math.pow((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)), 2.0));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - hi) / lo tmp = 0 if hi <= 1.445e+308: tmp = (1.0 + math.pow((x / lo), 3.0)) / (1.0 + (math.pow(((x + ((hi * t_0) - hi)) / lo), 2.0) + (((hi * ((hi - x) / lo)) - x) / lo))) else: tmp = math.sqrt(math.pow((1.0 + ((x + (hi * (t_0 + -1.0))) / lo)), 2.0)) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) tmp = 0.0 if (hi <= 1.445e+308) tmp = Float64(Float64(1.0 + (Float64(x / lo) ^ 3.0)) / Float64(1.0 + Float64((Float64(Float64(x + Float64(Float64(hi * t_0) - hi)) / lo) ^ 2.0) + Float64(Float64(Float64(hi * Float64(Float64(hi - x) / lo)) - x) / lo)))); else tmp = sqrt((Float64(1.0 + Float64(Float64(x + Float64(hi * Float64(t_0 + -1.0))) / 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.445e+308) tmp = (1.0 + ((x / lo) ^ 3.0)) / (1.0 + ((((x + ((hi * t_0) - hi)) / lo) ^ 2.0) + (((hi * ((hi - x) / lo)) - x) / lo))); else tmp = sqrt(((1.0 + ((x + (hi * (t_0 + -1.0))) / 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.445e+308], N[(N[(1.0 + N[Power[N[(x / lo), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[Power[N[(N[(x + N[(N[(hi * t$95$0), $MachinePrecision] - hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] + N[(N[(N[(hi * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[(hi * N[(t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
\mathbf{if}\;hi \leq 1.445 \cdot 10^{+308}:\\
\;\;\;\;\frac{1 + {\left(\frac{x}{lo}\right)}^{3}}{1 + \left({\left(\frac{x + \left(hi \cdot t\_0 - hi\right)}{lo}\right)}^{2} + \frac{hi \cdot \frac{hi - x}{lo} - x}{lo}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{\left(1 + \frac{x + hi \cdot \left(t\_0 + -1\right)}{lo}\right)}^{2}}\\
\end{array}
\end{array}
if hi < 1.445e308Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*19.1%
Simplified19.1%
flip3-+19.0%
Applied egg-rr18.3%
Taylor expanded in lo around 0 3.0%
associate-*r/23.8%
Simplified23.8%
Taylor expanded in hi around 0 23.9%
if 1.445e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*9.0%
Simplified9.0%
add-sqr-sqrt9.0%
sqrt-unprod9.0%
pow29.0%
add-sqr-sqrt5.1%
sqrt-unprod9.0%
sqr-neg9.0%
sqrt-unprod3.9%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
fmm-def19.9%
Simplified19.9%
Taylor expanded in hi around 0 19.9%
sub-neg19.9%
mul-1-neg19.9%
+-commutative19.9%
sub-neg19.9%
div-sub19.9%
metadata-eval19.9%
Simplified19.9%
Final simplification22.2%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* (+ x (fabs (* hi (+ (/ (- x hi) lo) -1.0)))) (/ 1.0 lo))))
double code(double lo, double hi, double x) {
return 1.0 + ((x + fabs((hi * (((x - hi) / lo) + -1.0)))) * (1.0 / 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 + ((x + abs((hi * (((x - hi) / lo) + (-1.0d0))))) * (1.0d0 / lo))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((x + Math.abs((hi * (((x - hi) / lo) + -1.0)))) * (1.0 / lo));
}
def code(lo, hi, x): return 1.0 + ((x + math.fabs((hi * (((x - hi) / lo) + -1.0)))) * (1.0 / lo))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(x + abs(Float64(hi * Float64(Float64(Float64(x - hi) / lo) + -1.0)))) * Float64(1.0 / lo))) end
function tmp = code(lo, hi, x) tmp = 1.0 + ((x + abs((hi * (((x - hi) / lo) + -1.0)))) * (1.0 / lo)); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(x + N[Abs[N[(hi * N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(x + \left|hi \cdot \left(\frac{x - hi}{lo} + -1\right)\right|\right) \cdot \frac{1}{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.8%
Simplified14.8%
add-sqr-sqrt9.7%
sqrt-unprod14.2%
sqr-neg14.2%
sqrt-unprod4.5%
add-sqr-sqrt13.6%
Applied egg-rr13.6%
div-inv13.6%
Applied egg-rr13.6%
add-sqr-sqrt4.6%
sqrt-unprod0.7%
pow20.7%
Applied egg-rr0.7%
unpow20.7%
rem-sqrt-square14.2%
sub-neg14.2%
neg-mul-114.2%
*-commutative14.2%
distribute-lft-in19.7%
Simplified19.7%
Final simplification19.7%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (+ x (* hi (+ (/ (- x hi) lo) -1.0))) lo)))
double code(double lo, double hi, double x) {
return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / 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 + ((x + (hi * (((x - hi) / lo) + (-1.0d0)))) / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo);
}
def code(lo, hi, x): return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo)
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(x + Float64(hi * Float64(Float64(Float64(x - hi) / lo) + -1.0))) / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(x + N[(hi * N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{x + hi \cdot \left(\frac{x - hi}{lo} + -1\right)}{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.8%
Simplified14.8%
add-sqr-sqrt9.7%
sqrt-unprod14.2%
sqr-neg14.2%
sqrt-unprod4.5%
add-sqr-sqrt13.6%
Applied egg-rr13.6%
Taylor expanded in hi around 0 19.1%
sub-neg19.1%
+-commutative19.1%
mul-1-neg19.1%
sub-neg19.1%
div-sub19.1%
metadata-eval19.1%
Simplified19.1%
Final simplification19.1%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* (/ (- x hi) lo) (- -1.0 (/ hi lo)))))
double code(double lo, double hi, double x) {
return 1.0 + (((x - hi) / lo) * (-1.0 - (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 = 1.0d0 + (((x - hi) / lo) * ((-1.0d0) - (hi / lo)))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (((x - hi) / lo) * (-1.0 - (hi / lo)));
}
def code(lo, hi, x): return 1.0 + (((x - hi) / lo) * (-1.0 - (hi / lo)))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(Float64(x - hi) / lo) * Float64(-1.0 - Float64(hi / lo)))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (((x - hi) / lo) * (-1.0 - (hi / lo))); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] * N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{x - hi}{lo} \cdot \left(-1 - \frac{hi}{lo}\right)
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
Simplified18.9%
Final simplification18.9%
(FPCore (lo hi x) :precision binary64 (/ (- x lo) hi))
double code(double lo, double hi, double x) {
return (x - 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 = (x - lo) / hi
end function
public static double code(double lo, double hi, double x) {
return (x - lo) / hi;
}
def code(lo, hi, x): return (x - lo) / hi
function code(lo, hi, x) return Float64(Float64(x - lo) / hi) end
function tmp = code(lo, hi, x) tmp = (x - lo) / hi; end
code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - lo}{hi}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
Final simplification18.8%
(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%
associate-*r/18.8%
neg-mul-118.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%
Final simplification18.7%
herbie shell --seed 2024112
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))