
(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 (/ (+ 1.0 (pow (* x (/ (- -1.0 (/ hi lo)) lo)) 3.0)) (+ (pow (- (fma hi (+ (/ x (pow lo 2.0)) (/ -1.0 lo)) (/ x lo))) 2.0) (+ 1.0 (* (+ 1.0 (/ hi lo)) (/ (- x hi) lo))))))
double code(double lo, double hi, double x) {
return (1.0 + pow((x * ((-1.0 - (hi / lo)) / lo)), 3.0)) / (pow(-fma(hi, ((x / pow(lo, 2.0)) + (-1.0 / lo)), (x / lo)), 2.0) + (1.0 + ((1.0 + (hi / lo)) * ((x - hi) / lo))));
}
function code(lo, hi, x) return Float64(Float64(1.0 + (Float64(x * Float64(Float64(-1.0 - Float64(hi / lo)) / lo)) ^ 3.0)) / Float64((Float64(-fma(hi, Float64(Float64(x / (lo ^ 2.0)) + Float64(-1.0 / lo)), Float64(x / lo))) ^ 2.0) + Float64(1.0 + Float64(Float64(1.0 + Float64(hi / lo)) * Float64(Float64(x - hi) / lo))))) end
code[lo_, hi_, x_] := N[(N[(1.0 + N[Power[N[(x * N[(N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[(-N[(hi * N[(N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision] + N[(-1.0 / lo), $MachinePrecision]), $MachinePrecision] + N[(x / lo), $MachinePrecision]), $MachinePrecision]), 2.0], $MachinePrecision] + N[(1.0 + N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1 + {\left(x \cdot \frac{-1 - \frac{hi}{lo}}{lo}\right)}^{3}}{{\left(-\mathsf{fma}\left(hi, \frac{x}{{lo}^{2}} + \frac{-1}{lo}, \frac{x}{lo}\right)\right)}^{2} + \left(1 + \left(1 + \frac{hi}{lo}\right) \cdot \frac{x - hi}{lo}\right)}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in hi around 0 32.2%
distribute-lft-out32.2%
mul-1-neg32.2%
fma-define32.2%
sub-neg32.2%
distribute-neg-frac32.2%
metadata-eval32.2%
Simplified32.2%
Taylor expanded in x around inf 97.8%
mul-1-neg97.8%
associate-/l*97.8%
distribute-lft-neg-in97.8%
+-commutative97.8%
Simplified97.8%
Final simplification97.8%
(FPCore (lo hi x) :precision binary64 (/ (+ 1.0 (pow (/ x (- lo)) 3.0)) (+ (pow (- (fma hi (+ (/ x (pow lo 2.0)) (/ -1.0 lo)) (/ x lo))) 2.0) (+ 1.0 (* (+ 1.0 (/ hi lo)) (/ (- x hi) lo))))))
double code(double lo, double hi, double x) {
return (1.0 + pow((x / -lo), 3.0)) / (pow(-fma(hi, ((x / pow(lo, 2.0)) + (-1.0 / lo)), (x / lo)), 2.0) + (1.0 + ((1.0 + (hi / lo)) * ((x - hi) / lo))));
}
function code(lo, hi, x) return Float64(Float64(1.0 + (Float64(x / Float64(-lo)) ^ 3.0)) / Float64((Float64(-fma(hi, Float64(Float64(x / (lo ^ 2.0)) + Float64(-1.0 / lo)), Float64(x / lo))) ^ 2.0) + Float64(1.0 + Float64(Float64(1.0 + Float64(hi / lo)) * Float64(Float64(x - hi) / lo))))) end
code[lo_, hi_, x_] := N[(N[(1.0 + N[Power[N[(x / (-lo)), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[(-N[(hi * N[(N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision] + N[(-1.0 / lo), $MachinePrecision]), $MachinePrecision] + N[(x / lo), $MachinePrecision]), $MachinePrecision]), 2.0], $MachinePrecision] + N[(1.0 + N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1 + {\left(\frac{x}{-lo}\right)}^{3}}{{\left(-\mathsf{fma}\left(hi, \frac{x}{{lo}^{2}} + \frac{-1}{lo}, \frac{x}{lo}\right)\right)}^{2} + \left(1 + \left(1 + \frac{hi}{lo}\right) \cdot \frac{x - hi}{lo}\right)}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in hi around 0 32.2%
distribute-lft-out32.2%
mul-1-neg32.2%
fma-define32.2%
sub-neg32.2%
distribute-neg-frac32.2%
metadata-eval32.2%
Simplified32.2%
Taylor expanded in hi around 0 97.8%
mul-1-neg32.1%
distribute-frac-neg232.1%
Simplified97.8%
Final simplification97.8%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (+ 1.0 (/ hi lo))))
(/
(+ 1.0 (pow (* t_0 (/ (- hi x) lo)) 3.0))
(+
(+ 1.0 (* t_0 (/ (- x hi) lo)))
(pow (- (* hi (- (/ 1.0 lo) (/ x (pow lo 2.0)))) (/ x lo)) 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = 1.0 + (hi / lo);
return (1.0 + pow((t_0 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_0 * ((x - hi) / lo))) + pow(((hi * ((1.0 / lo) - (x / pow(lo, 2.0)))) - (x / lo)), 2.0));
}
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
t_0 = 1.0d0 + (hi / lo)
code = (1.0d0 + ((t_0 * ((hi - x) / lo)) ** 3.0d0)) / ((1.0d0 + (t_0 * ((x - hi) / lo))) + (((hi * ((1.0d0 / lo) - (x / (lo ** 2.0d0)))) - (x / lo)) ** 2.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = 1.0 + (hi / lo);
return (1.0 + Math.pow((t_0 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_0 * ((x - hi) / lo))) + Math.pow(((hi * ((1.0 / lo) - (x / Math.pow(lo, 2.0)))) - (x / lo)), 2.0));
}
def code(lo, hi, x): t_0 = 1.0 + (hi / lo) return (1.0 + math.pow((t_0 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_0 * ((x - hi) / lo))) + math.pow(((hi * ((1.0 / lo) - (x / math.pow(lo, 2.0)))) - (x / lo)), 2.0))
function code(lo, hi, x) t_0 = Float64(1.0 + Float64(hi / lo)) return Float64(Float64(1.0 + (Float64(t_0 * Float64(Float64(hi - x) / lo)) ^ 3.0)) / Float64(Float64(1.0 + Float64(t_0 * Float64(Float64(x - hi) / lo))) + (Float64(Float64(hi * Float64(Float64(1.0 / lo) - Float64(x / (lo ^ 2.0)))) - Float64(x / lo)) ^ 2.0))) end
function tmp = code(lo, hi, x) t_0 = 1.0 + (hi / lo); tmp = (1.0 + ((t_0 * ((hi - x) / lo)) ^ 3.0)) / ((1.0 + (t_0 * ((x - hi) / lo))) + (((hi * ((1.0 / lo) - (x / (lo ^ 2.0)))) - (x / lo)) ^ 2.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 + N[Power[N[(t$95$0 * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(t$95$0 * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[Power[N[(N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + \frac{hi}{lo}\\
\frac{1 + {\left(t\_0 \cdot \frac{hi - x}{lo}\right)}^{3}}{\left(1 + t\_0 \cdot \frac{x - hi}{lo}\right) + {\left(hi \cdot \left(\frac{1}{lo} - \frac{x}{{lo}^{2}}\right) - \frac{x}{lo}\right)}^{2}}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in hi around 0 32.2%
distribute-lft-out32.2%
mul-1-neg32.2%
fma-define32.2%
sub-neg32.2%
distribute-neg-frac32.2%
metadata-eval32.2%
Simplified32.2%
Taylor expanded in hi around 0 32.2%
Final simplification32.2%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x hi) lo)) (t_1 (+ 1.0 (/ hi lo))))
(/
(+ 1.0 (pow (* t_1 (/ (- hi x) lo)) 3.0))
(+ (+ 1.0 (* t_1 t_0)) (pow t_0 2.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double t_1 = 1.0 + (hi / lo);
return (1.0 + pow((t_1 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_1 * t_0)) + pow(t_0, 2.0));
}
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
t_0 = (x - hi) / lo
t_1 = 1.0d0 + (hi / lo)
code = (1.0d0 + ((t_1 * ((hi - x) / lo)) ** 3.0d0)) / ((1.0d0 + (t_1 * t_0)) + (t_0 ** 2.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - hi) / lo;
double t_1 = 1.0 + (hi / lo);
return (1.0 + Math.pow((t_1 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_1 * t_0)) + Math.pow(t_0, 2.0));
}
def code(lo, hi, x): t_0 = (x - hi) / lo t_1 = 1.0 + (hi / lo) return (1.0 + math.pow((t_1 * ((hi - x) / lo)), 3.0)) / ((1.0 + (t_1 * t_0)) + math.pow(t_0, 2.0))
function code(lo, hi, x) t_0 = Float64(Float64(x - hi) / lo) t_1 = Float64(1.0 + Float64(hi / lo)) return Float64(Float64(1.0 + (Float64(t_1 * Float64(Float64(hi - x) / lo)) ^ 3.0)) / Float64(Float64(1.0 + Float64(t_1 * t_0)) + (t_0 ^ 2.0))) end
function tmp = code(lo, hi, x) t_0 = (x - hi) / lo; t_1 = 1.0 + (hi / lo); tmp = (1.0 + ((t_1 * ((hi - x) / lo)) ^ 3.0)) / ((1.0 + (t_1 * t_0)) + (t_0 ^ 2.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 + N[Power[N[(t$95$1 * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(t$95$1 * t$95$0), $MachinePrecision]), $MachinePrecision] + N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - hi}{lo}\\
t_1 := 1 + \frac{hi}{lo}\\
\frac{1 + {\left(t\_1 \cdot \frac{hi - x}{lo}\right)}^{3}}{\left(1 + t\_1 \cdot t\_0\right) + {t\_0}^{2}}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in lo around inf 0.0%
unpow20.0%
unpow20.0%
times-frac32.2%
unpow232.2%
Simplified32.2%
Final simplification32.2%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- hi x) lo)))
(/
(+ 1.0 (pow (* (+ 1.0 (/ hi lo)) t_0) 3.0))
(+ (pow (/ x (- lo)) 2.0) (- 1.0 t_0)))))
double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
return (1.0 + pow(((1.0 + (hi / lo)) * t_0), 3.0)) / (pow((x / -lo), 2.0) + (1.0 - t_0));
}
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
t_0 = (hi - x) / lo
code = (1.0d0 + (((1.0d0 + (hi / lo)) * t_0) ** 3.0d0)) / (((x / -lo) ** 2.0d0) + (1.0d0 - t_0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
return (1.0 + Math.pow(((1.0 + (hi / lo)) * t_0), 3.0)) / (Math.pow((x / -lo), 2.0) + (1.0 - t_0));
}
def code(lo, hi, x): t_0 = (hi - x) / lo return (1.0 + math.pow(((1.0 + (hi / lo)) * t_0), 3.0)) / (math.pow((x / -lo), 2.0) + (1.0 - t_0))
function code(lo, hi, x) t_0 = Float64(Float64(hi - x) / lo) return Float64(Float64(1.0 + (Float64(Float64(1.0 + Float64(hi / lo)) * t_0) ^ 3.0)) / Float64((Float64(x / Float64(-lo)) ^ 2.0) + Float64(1.0 - t_0))) end
function tmp = code(lo, hi, x) t_0 = (hi - x) / lo; tmp = (1.0 + (((1.0 + (hi / lo)) * t_0) ^ 3.0)) / (((x / -lo) ^ 2.0) + (1.0 - t_0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]}, N[(N[(1.0 + N[Power[N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[(x / (-lo)), $MachinePrecision], 2.0], $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi - x}{lo}\\
\frac{1 + {\left(\left(1 + \frac{hi}{lo}\right) \cdot t\_0\right)}^{3}}{{\left(\frac{x}{-lo}\right)}^{2} + \left(1 - t\_0\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in lo around inf 29.6%
mul-1-neg29.6%
distribute-frac-neg29.6%
sub-neg29.6%
distribute-neg-in29.6%
neg-mul-129.6%
remove-double-neg29.6%
+-commutative29.6%
neg-mul-129.6%
sub-neg29.6%
Simplified29.6%
Taylor expanded in hi around 0 32.1%
mul-1-neg32.1%
distribute-frac-neg232.1%
Simplified32.1%
Final simplification32.1%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (+ 1.0 (/ hi lo))) (t_1 (/ (- hi x) lo)) (t_2 (* t_0 t_1))) (/ (+ 1.0 (pow t_2 3.0)) (+ (- 1.0 t_1) (* t_1 (* t_0 t_2))))))
double code(double lo, double hi, double x) {
double t_0 = 1.0 + (hi / lo);
double t_1 = (hi - x) / lo;
double t_2 = t_0 * t_1;
return (1.0 + pow(t_2, 3.0)) / ((1.0 - t_1) + (t_1 * (t_0 * t_2)));
}
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) :: t_2
t_0 = 1.0d0 + (hi / lo)
t_1 = (hi - x) / lo
t_2 = t_0 * t_1
code = (1.0d0 + (t_2 ** 3.0d0)) / ((1.0d0 - t_1) + (t_1 * (t_0 * t_2)))
end function
public static double code(double lo, double hi, double x) {
double t_0 = 1.0 + (hi / lo);
double t_1 = (hi - x) / lo;
double t_2 = t_0 * t_1;
return (1.0 + Math.pow(t_2, 3.0)) / ((1.0 - t_1) + (t_1 * (t_0 * t_2)));
}
def code(lo, hi, x): t_0 = 1.0 + (hi / lo) t_1 = (hi - x) / lo t_2 = t_0 * t_1 return (1.0 + math.pow(t_2, 3.0)) / ((1.0 - t_1) + (t_1 * (t_0 * t_2)))
function code(lo, hi, x) t_0 = Float64(1.0 + Float64(hi / lo)) t_1 = Float64(Float64(hi - x) / lo) t_2 = Float64(t_0 * t_1) return Float64(Float64(1.0 + (t_2 ^ 3.0)) / Float64(Float64(1.0 - t_1) + Float64(t_1 * Float64(t_0 * t_2)))) end
function tmp = code(lo, hi, x) t_0 = 1.0 + (hi / lo); t_1 = (hi - x) / lo; t_2 = t_0 * t_1; tmp = (1.0 + (t_2 ^ 3.0)) / ((1.0 - t_1) + (t_1 * (t_0 * t_2))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 * t$95$1), $MachinePrecision]}, N[(N[(1.0 + N[Power[t$95$2, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 - t$95$1), $MachinePrecision] + N[(t$95$1 * N[(t$95$0 * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + \frac{hi}{lo}\\
t_1 := \frac{hi - x}{lo}\\
t_2 := t\_0 \cdot t\_1\\
\frac{1 + {t\_2}^{3}}{\left(1 - t\_1\right) + t\_1 \cdot \left(t\_0 \cdot t\_2\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
+-commutative18.9%
flip3-+18.9%
pow318.9%
metadata-eval18.9%
+-commutative18.9%
pow318.9%
*-commutative18.9%
Applied egg-rr18.9%
*-commutative18.9%
*-commutative18.9%
*-commutative18.9%
Simplified18.9%
Taylor expanded in lo around inf 29.6%
mul-1-neg29.6%
distribute-frac-neg29.6%
sub-neg29.6%
distribute-neg-in29.6%
neg-mul-129.6%
remove-double-neg29.6%
+-commutative29.6%
neg-mul-129.6%
sub-neg29.6%
Simplified29.6%
unpow229.6%
*-commutative29.6%
associate-*r*29.6%
*-commutative29.6%
Applied egg-rr29.6%
Final simplification29.6%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (/ (- x hi) lo) (- -1.0 (* (/ hi lo) (+ (/ hi lo) -1.0))))))
double code(double lo, double hi, double x) {
return 1.0 + (((x - hi) / lo) / (-1.0 - ((hi / lo) * ((hi / lo) + -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 + (((x - hi) / lo) / ((-1.0d0) - ((hi / lo) * ((hi / lo) + (-1.0d0)))))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (((x - hi) / lo) / (-1.0 - ((hi / lo) * ((hi / lo) + -1.0))));
}
def code(lo, hi, x): return 1.0 + (((x - hi) / lo) / (-1.0 - ((hi / lo) * ((hi / lo) + -1.0))))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(Float64(x - hi) / lo) / Float64(-1.0 - Float64(Float64(hi / lo) * Float64(Float64(hi / lo) + -1.0))))) end
function tmp = code(lo, hi, x) tmp = 1.0 + (((x - hi) / lo) / (-1.0 - ((hi / lo) * ((hi / lo) + -1.0)))); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] / N[(-1.0 - N[(N[(hi / lo), $MachinePrecision] * N[(N[(hi / lo), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{\frac{x - hi}{lo}}{-1 - \frac{hi}{lo} \cdot \left(\frac{hi}{lo} + -1\right)}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
flip3--18.9%
associate-*r/18.9%
metadata-eval18.9%
metadata-eval18.9%
distribute-rgt-out18.9%
+-commutative18.9%
Applied egg-rr18.9%
Taylor expanded in lo around inf 21.1%
associate-*r/21.1%
neg-mul-121.1%
Simplified21.1%
Final simplification21.1%
(FPCore (lo hi x) :precision binary64 (* (/ hi lo) (/ hi lo)))
double code(double lo, double hi, double x) {
return (hi / 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 = (hi / lo) * (hi / lo)
end function
public static double code(double lo, double hi, double x) {
return (hi / lo) * (hi / lo);
}
def code(lo, hi, x): return (hi / lo) * (hi / lo)
function code(lo, hi, x) return Float64(Float64(hi / lo) * Float64(hi / lo)) end
function tmp = code(lo, hi, x) tmp = (hi / lo) * (hi / lo); end
code[lo_, hi_, x_] := N[(N[(hi / lo), $MachinePrecision] * N[(hi / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{hi}{lo} \cdot \frac{hi}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
distribute-lft-out--0.0%
associate-*r*0.0%
*-commutative0.0%
associate-*r/0.0%
distribute-lft-out--0.0%
div-sub0.0%
+-commutative0.0%
mul-1-neg0.0%
Simplified18.9%
add-cbrt-cube18.9%
pow318.9%
+-commutative18.9%
*-commutative18.9%
fma-define18.9%
Applied egg-rr18.9%
Taylor expanded in hi around inf 0.0%
unpow20.0%
unpow20.0%
times-frac19.3%
unpow219.3%
Simplified19.3%
unpow219.3%
Applied egg-rr19.3%
Final simplification19.3%
(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(Float64(-lo) / 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-frac218.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 2024039
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))