
(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 (/ 1.0 (- 1.0 (/ (- hi (+ x (* x (/ hi lo)))) lo)))))
(if (or (<= x -1.32e+154) (not (<= x 8.1e+148)))
(+
t_0
(/
(pow (/ (- (+ x (* (/ hi lo) (- x hi))) hi) lo) 2.0)
(+ -1.0 (/ (+ hi (- (/ (* hi (- hi x)) lo) x)) lo))))
(+ t_0 (/ (pow x 2.0) (* (pow lo 2.0) (- -1.0 (/ x lo))))))))
double code(double lo, double hi, double x) {
double t_0 = 1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo));
double tmp;
if ((x <= -1.32e+154) || !(x <= 8.1e+148)) {
tmp = t_0 + (pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)));
} else {
tmp = t_0 + (pow(x, 2.0) / (pow(lo, 2.0) * (-1.0 - (x / lo))));
}
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 = 1.0d0 / (1.0d0 - ((hi - (x + (x * (hi / lo)))) / lo))
if ((x <= (-1.32d+154)) .or. (.not. (x <= 8.1d+148))) then
tmp = t_0 + (((((x + ((hi / lo) * (x - hi))) - hi) / lo) ** 2.0d0) / ((-1.0d0) + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)))
else
tmp = t_0 + ((x ** 2.0d0) / ((lo ** 2.0d0) * ((-1.0d0) - (x / lo))))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = 1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo));
double tmp;
if ((x <= -1.32e+154) || !(x <= 8.1e+148)) {
tmp = t_0 + (Math.pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)));
} else {
tmp = t_0 + (Math.pow(x, 2.0) / (Math.pow(lo, 2.0) * (-1.0 - (x / lo))));
}
return tmp;
}
def code(lo, hi, x): t_0 = 1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo)) tmp = 0 if (x <= -1.32e+154) or not (x <= 8.1e+148): tmp = t_0 + (math.pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo))) else: tmp = t_0 + (math.pow(x, 2.0) / (math.pow(lo, 2.0) * (-1.0 - (x / lo)))) return tmp
function code(lo, hi, x) t_0 = Float64(1.0 / Float64(1.0 - Float64(Float64(hi - Float64(x + Float64(x * Float64(hi / lo)))) / lo))) tmp = 0.0 if ((x <= -1.32e+154) || !(x <= 8.1e+148)) tmp = Float64(t_0 + Float64((Float64(Float64(Float64(x + Float64(Float64(hi / lo) * Float64(x - hi))) - hi) / lo) ^ 2.0) / Float64(-1.0 + Float64(Float64(hi + Float64(Float64(Float64(hi * Float64(hi - x)) / lo) - x)) / lo)))); else tmp = Float64(t_0 + Float64((x ^ 2.0) / Float64((lo ^ 2.0) * Float64(-1.0 - Float64(x / lo))))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = 1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo)); tmp = 0.0; if ((x <= -1.32e+154) || ~((x <= 8.1e+148))) tmp = t_0 + (((((x + ((hi / lo) * (x - hi))) - hi) / lo) ^ 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo))); else tmp = t_0 + ((x ^ 2.0) / ((lo ^ 2.0) * (-1.0 - (x / lo)))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(1.0 / N[(1.0 - N[(N[(hi - N[(x + N[(x * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[x, -1.32e+154], N[Not[LessEqual[x, 8.1e+148]], $MachinePrecision]], N[(t$95$0 + N[(N[Power[N[(N[(N[(x + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] / N[(-1.0 + N[(N[(hi + N[(N[(N[(hi * N[(hi - x), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(N[Power[x, 2.0], $MachinePrecision] / N[(N[Power[lo, 2.0], $MachinePrecision] * N[(-1.0 - N[(x / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{1 - \frac{hi - \left(x + x \cdot \frac{hi}{lo}\right)}{lo}}\\
\mathbf{if}\;x \leq -1.32 \cdot 10^{+154} \lor \neg \left(x \leq 8.1 \cdot 10^{+148}\right):\\
\;\;\;\;t\_0 + \frac{{\left(\frac{\left(x + \frac{hi}{lo} \cdot \left(x - hi\right)\right) - hi}{lo}\right)}^{2}}{-1 + \frac{hi + \left(\frac{hi \cdot \left(hi - x\right)}{lo} - x\right)}{lo}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + \frac{{x}^{2}}{{lo}^{2} \cdot \left(-1 - \frac{x}{lo}\right)}\\
\end{array}
\end{array}
if x < -1.31999999999999998e154 or 8.1e148 < x Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*15.4%
Simplified15.4%
flip-+14.6%
metadata-eval14.6%
div-sub14.6%
Applied egg-rr14.6%
associate-+r-14.3%
associate-/r/14.3%
associate-+r-14.3%
associate-/r/14.3%
Simplified14.3%
Taylor expanded in x around inf 20.3%
Taylor expanded in lo around inf 69.2%
if -1.31999999999999998e154 < x < 8.1e148Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*15.5%
Simplified15.5%
flip-+14.8%
metadata-eval14.8%
div-sub14.8%
Applied egg-rr14.8%
associate-+r-14.8%
associate-/r/14.8%
associate-+r-14.8%
associate-/r/14.8%
Simplified14.8%
Taylor expanded in x around inf 21.0%
Taylor expanded in hi around 0 99.3%
Final simplification91.6%
(FPCore (lo hi x) :precision binary64 (+ (/ 1.0 (- 1.0 (/ (- hi (+ x (* x (/ hi lo)))) lo))) (/ (pow (/ (- (+ x (* (/ hi lo) (- x hi))) hi) lo) 2.0) (+ -1.0 (/ (+ hi (- (/ (* hi (- hi x)) lo) x)) lo)))))
double code(double lo, double hi, double x) {
return (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - 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 / (1.0d0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (((((x + ((hi / lo) * (x - hi))) - hi) / lo) ** 2.0d0) / ((-1.0d0) + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)))
end function
public static double code(double lo, double hi, double x) {
return (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (Math.pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)));
}
def code(lo, hi, x): return (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (math.pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo)))
function code(lo, hi, x) return Float64(Float64(1.0 / Float64(1.0 - Float64(Float64(hi - Float64(x + Float64(x * Float64(hi / lo)))) / lo))) + Float64((Float64(Float64(Float64(x + Float64(Float64(hi / lo) * Float64(x - hi))) - hi) / lo) ^ 2.0) / Float64(-1.0 + Float64(Float64(hi + Float64(Float64(Float64(hi * Float64(hi - x)) / lo) - x)) / lo)))) end
function tmp = code(lo, hi, x) tmp = (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (((((x + ((hi / lo) * (x - hi))) - hi) / lo) ^ 2.0) / (-1.0 + ((hi + (((hi * (hi - x)) / lo) - x)) / lo))); end
code[lo_, hi_, x_] := N[(N[(1.0 / N[(1.0 - N[(N[(hi - N[(x + N[(x * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[N[(N[(N[(x + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] / N[(-1.0 + N[(N[(hi + N[(N[(N[(hi * N[(hi - x), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{1 - \frac{hi - \left(x + x \cdot \frac{hi}{lo}\right)}{lo}} + \frac{{\left(\frac{\left(x + \frac{hi}{lo} \cdot \left(x - hi\right)\right) - hi}{lo}\right)}^{2}}{-1 + \frac{hi + \left(\frac{hi \cdot \left(hi - x\right)}{lo} - x\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*15.5%
Simplified15.5%
flip-+14.7%
metadata-eval14.7%
div-sub14.7%
Applied egg-rr14.7%
associate-+r-14.6%
associate-/r/14.6%
associate-+r-14.6%
associate-/r/14.6%
Simplified14.6%
Taylor expanded in x around inf 20.8%
Taylor expanded in lo around inf 74.5%
Final simplification74.5%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)))
(if (<= hi 1.51e+308)
(+
(/ 1.0 (- 1.0 (/ (- hi (+ x (* x (/ hi lo)))) lo)))
(/ (pow (/ (- (+ x (* (/ hi lo) (- x hi))) hi) lo) 2.0) (- -1.0 t_0)))
(+ 1.0 (/ (fma hi (+ t_0 -1.0) x) lo)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double tmp;
if (hi <= 1.51e+308) {
tmp = (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 - t_0));
} else {
tmp = 1.0 + (fma(hi, (t_0 + -1.0), x) / lo);
}
return tmp;
}
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) tmp = 0.0 if (hi <= 1.51e+308) tmp = Float64(Float64(1.0 / Float64(1.0 - Float64(Float64(hi - Float64(x + Float64(x * Float64(hi / lo)))) / lo))) + Float64((Float64(Float64(Float64(x + Float64(Float64(hi / lo) * Float64(x - hi))) - hi) / lo) ^ 2.0) / Float64(-1.0 - t_0))); else tmp = Float64(1.0 + Float64(fma(hi, Float64(t_0 + -1.0), x) / lo)); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, If[LessEqual[hi, 1.51e+308], N[(N[(1.0 / N[(1.0 - N[(N[(hi - N[(x + N[(x * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[N[(N[(N[(x + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] / N[(-1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(hi * N[(t$95$0 + -1.0), $MachinePrecision] + x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
\mathbf{if}\;hi \leq 1.51 \cdot 10^{+308}:\\
\;\;\;\;\frac{1}{1 - \frac{hi - \left(x + x \cdot \frac{hi}{lo}\right)}{lo}} + \frac{{\left(\frac{\left(x + \frac{hi}{lo} \cdot \left(x - hi\right)\right) - hi}{lo}\right)}^{2}}{-1 - t\_0}\\
\mathbf{else}:\\
\;\;\;\;1 + \frac{\mathsf{fma}\left(hi, t\_0 + -1, x\right)}{lo}\\
\end{array}
\end{array}
if hi < 1.51e308Initial 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%
flip-+18.4%
metadata-eval18.4%
div-sub18.4%
Applied egg-rr18.4%
associate-+r-18.4%
associate-/r/18.4%
associate-+r-18.4%
associate-/r/18.4%
Simplified18.4%
Taylor expanded in x around inf 25.5%
Taylor expanded in lo around inf 27.0%
associate--l+27.0%
div-sub27.0%
Simplified27.0%
if 1.51e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*8.0%
Simplified8.0%
add-sqr-sqrt4.9%
sqrt-unprod7.9%
sqr-neg7.9%
sqrt-unprod3.0%
add-sqr-sqrt6.3%
associate-+r-6.0%
div-sub6.0%
clear-num6.0%
un-div-inv6.0%
Applied egg-rr6.0%
associate-+r-6.0%
+-commutative6.0%
associate-/r/6.0%
*-commutative6.0%
fma-define6.0%
Applied egg-rr6.0%
associate--l+6.0%
div-sub6.0%
div-sub6.0%
fma-undefine6.0%
associate-*r/0.7%
*-commutative0.7%
+-commutative0.7%
div-sub0.7%
Simplified19.4%
Final simplification24.7%
(FPCore (lo hi x)
:precision binary64
(if (<= hi 1.51e+308)
(+
(/ 1.0 (- 1.0 (/ (- hi (+ x (* x (/ hi lo)))) lo)))
(/ (pow (/ (- (+ x (* (/ hi lo) (- x hi))) hi) lo) 2.0) (- -1.0 (/ x lo))))
(+ 1.0 (/ (fma hi (+ (/ (- x hi) lo) -1.0) x) lo))))
double code(double lo, double hi, double x) {
double tmp;
if (hi <= 1.51e+308) {
tmp = (1.0 / (1.0 - ((hi - (x + (x * (hi / lo)))) / lo))) + (pow((((x + ((hi / lo) * (x - hi))) - hi) / lo), 2.0) / (-1.0 - (x / lo)));
} else {
tmp = 1.0 + (fma(hi, (((x - hi) / lo) + -1.0), x) / lo);
}
return tmp;
}
function code(lo, hi, x) tmp = 0.0 if (hi <= 1.51e+308) tmp = Float64(Float64(1.0 / Float64(1.0 - Float64(Float64(hi - Float64(x + Float64(x * Float64(hi / lo)))) / lo))) + Float64((Float64(Float64(Float64(x + Float64(Float64(hi / lo) * Float64(x - hi))) - hi) / lo) ^ 2.0) / Float64(-1.0 - Float64(x / lo)))); else tmp = Float64(1.0 + Float64(fma(hi, Float64(Float64(Float64(x - hi) / lo) + -1.0), x) / lo)); end return tmp end
code[lo_, hi_, x_] := If[LessEqual[hi, 1.51e+308], N[(N[(1.0 / N[(1.0 - N[(N[(hi - N[(x + N[(x * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[N[(N[(N[(x + N[(N[(hi / lo), $MachinePrecision] * N[(x - hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - hi), $MachinePrecision] / lo), $MachinePrecision], 2.0], $MachinePrecision] / N[(-1.0 - N[(x / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(hi * N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + -1.0), $MachinePrecision] + x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;hi \leq 1.51 \cdot 10^{+308}:\\
\;\;\;\;\frac{1}{1 - \frac{hi - \left(x + x \cdot \frac{hi}{lo}\right)}{lo}} + \frac{{\left(\frac{\left(x + \frac{hi}{lo} \cdot \left(x - hi\right)\right) - hi}{lo}\right)}^{2}}{-1 - \frac{x}{lo}}\\
\mathbf{else}:\\
\;\;\;\;1 + \frac{\mathsf{fma}\left(hi, \frac{x - hi}{lo} + -1, x\right)}{lo}\\
\end{array}
\end{array}
if hi < 1.51e308Initial 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%
flip-+18.4%
metadata-eval18.4%
div-sub18.4%
Applied egg-rr18.4%
associate-+r-18.4%
associate-/r/18.4%
associate-+r-18.4%
associate-/r/18.4%
Simplified18.4%
Taylor expanded in x around inf 25.5%
Taylor expanded in hi around 0 25.5%
if 1.51e308 < hi Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*8.0%
Simplified8.0%
add-sqr-sqrt4.9%
sqrt-unprod7.9%
sqr-neg7.9%
sqrt-unprod3.0%
add-sqr-sqrt6.3%
associate-+r-6.0%
div-sub6.0%
clear-num6.0%
un-div-inv6.0%
Applied egg-rr6.0%
associate-+r-6.0%
+-commutative6.0%
associate-/r/6.0%
*-commutative6.0%
fma-define6.0%
Applied egg-rr6.0%
associate--l+6.0%
div-sub6.0%
div-sub6.0%
fma-undefine6.0%
associate-*r/0.7%
*-commutative0.7%
+-commutative0.7%
div-sub0.7%
Simplified19.4%
Final simplification23.7%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (fma hi (+ (/ (- x hi) lo) -1.0) x) lo)))
double code(double lo, double hi, double x) {
return 1.0 + (fma(hi, (((x - hi) / lo) + -1.0), x) / lo);
}
function code(lo, hi, x) return Float64(1.0 + Float64(fma(hi, Float64(Float64(Float64(x - hi) / lo) + -1.0), x) / lo)) end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(hi * N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + -1.0), $MachinePrecision] + x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{\mathsf{fma}\left(hi, \frac{x - hi}{lo} + -1, x\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*15.5%
Simplified15.5%
add-sqr-sqrt5.8%
sqrt-unprod14.9%
sqr-neg14.9%
sqrt-unprod9.1%
add-sqr-sqrt14.6%
associate-+r-14.5%
div-sub14.5%
clear-num14.5%
un-div-inv14.5%
Applied egg-rr14.5%
associate-+r-14.5%
+-commutative14.5%
associate-/r/14.5%
*-commutative14.5%
fma-define14.5%
Applied egg-rr14.5%
associate--l+14.5%
div-sub14.5%
div-sub14.5%
fma-undefine14.5%
associate-*r/0.7%
*-commutative0.7%
+-commutative0.7%
div-sub0.7%
Simplified19.1%
Final simplification19.1%
(FPCore (lo hi x) :precision binary64 (- (- 1.0 (pow (/ hi lo) 2.0)) (/ hi lo)))
double code(double lo, double hi, double x) {
return (1.0 - pow((hi / lo), 2.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 - ((hi / lo) ** 2.0d0)) - (hi / lo)
end function
public static double code(double lo, double hi, double x) {
return (1.0 - Math.pow((hi / lo), 2.0)) - (hi / lo);
}
def code(lo, hi, x): return (1.0 - math.pow((hi / lo), 2.0)) - (hi / lo)
function code(lo, hi, x) return Float64(Float64(1.0 - (Float64(hi / lo) ^ 2.0)) - Float64(hi / lo)) end
function tmp = code(lo, hi, x) tmp = (1.0 - ((hi / lo) ^ 2.0)) - (hi / lo); end
code[lo_, hi_, x_] := N[(N[(1.0 - N[Power[N[(hi / lo), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - N[(hi / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(1 - {\left(\frac{hi}{lo}\right)}^{2}\right) - \frac{hi}{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*15.5%
Simplified15.5%
unsub-neg15.5%
add-sqr-sqrt9.6%
sqrt-unprod15.2%
sqr-neg15.2%
sqrt-unprod5.5%
add-sqr-sqrt14.6%
*-un-lft-identity14.6%
neg-mul-114.6%
cancel-sign-sub-inv14.6%
Applied egg-rr14.6%
*-lft-identity14.6%
associate-+r-14.5%
associate-/r/14.5%
Simplified14.5%
Taylor expanded in x around 0 0.0%
mul-1-neg0.0%
unsub-neg0.0%
unpow20.0%
unpow20.0%
times-frac19.0%
unpow219.0%
Simplified19.0%
(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*15.5%
Simplified15.5%
Taylor expanded in hi around 0 18.8%
sub-neg18.8%
+-commutative18.8%
neg-mul-118.8%
sub-neg18.8%
div-sub18.8%
metadata-eval18.8%
Simplified18.8%
Final simplification18.8%
(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(Float64(hi * 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[(N[(hi * N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{hi \cdot \left(1 + \frac{hi}{lo}\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*15.5%
Simplified15.5%
Taylor expanded in hi around 0 18.8%
sub-neg18.8%
+-commutative18.8%
neg-mul-118.8%
sub-neg18.8%
div-sub18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in x around 0 18.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 lo around 0 18.8%
+-commutative18.8%
mul-1-neg18.8%
unsub-neg18.8%
+-commutative18.8%
mul-1-neg18.8%
unsub-neg18.8%
Simplified18.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%
herbie shell --seed 2024156
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))