
(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 7 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 (pow (cbrt hi) 2.0)))
(sqrt
(pow
(+
1.0
(/
(+
x
(+
(fma
(* hi (pow (cbrt lo) -2.0))
(/ (- x hi) (cbrt lo))
(* (cbrt hi) (- t_0)))
(fma (- (cbrt hi)) t_0 (* (cbrt hi) (exp (* 2.0 (log (cbrt hi))))))))
lo))
2.0))))
double code(double lo, double hi, double x) {
double t_0 = pow(cbrt(hi), 2.0);
return sqrt(pow((1.0 + ((x + (fma((hi * pow(cbrt(lo), -2.0)), ((x - hi) / cbrt(lo)), (cbrt(hi) * -t_0)) + fma(-cbrt(hi), t_0, (cbrt(hi) * exp((2.0 * log(cbrt(hi)))))))) / lo)), 2.0));
}
function code(lo, hi, x) t_0 = cbrt(hi) ^ 2.0 return sqrt((Float64(1.0 + Float64(Float64(x + Float64(fma(Float64(hi * (cbrt(lo) ^ -2.0)), Float64(Float64(x - hi) / cbrt(lo)), Float64(cbrt(hi) * Float64(-t_0))) + fma(Float64(-cbrt(hi)), t_0, Float64(cbrt(hi) * exp(Float64(2.0 * log(cbrt(hi)))))))) / lo)) ^ 2.0)) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[Power[hi, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[(N[(N[(hi * N[Power[N[Power[lo, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(x - hi), $MachinePrecision] / N[Power[lo, 1/3], $MachinePrecision]), $MachinePrecision] + N[(N[Power[hi, 1/3], $MachinePrecision] * (-t$95$0)), $MachinePrecision]), $MachinePrecision] + N[((-N[Power[hi, 1/3], $MachinePrecision]) * t$95$0 + N[(N[Power[hi, 1/3], $MachinePrecision] * N[Exp[N[(2.0 * N[Log[N[Power[hi, 1/3], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\sqrt[3]{hi}\right)}^{2}\\
\sqrt{{\left(1 + \frac{x + \left(\mathsf{fma}\left(hi \cdot {\left(\sqrt[3]{lo}\right)}^{-2}, \frac{x - hi}{\sqrt[3]{lo}}, \sqrt[3]{hi} \cdot \left(-t\_0\right)\right) + \mathsf{fma}\left(-\sqrt[3]{hi}, t\_0, \sqrt[3]{hi} \cdot e^{2 \cdot \log \left(\sqrt[3]{hi}\right)}\right)\right)}{lo}\right)}^{2}}
\end{array}
\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.0%
Simplified15.0%
add-sqr-sqrt15.0%
sqrt-unprod15.0%
pow215.0%
Applied egg-rr19.2%
*-un-lft-identity19.2%
add-cube-cbrt19.2%
unpow219.2%
frac-times19.2%
fmm-def14.6%
associate-*r*14.6%
add-cube-cbrt14.6%
prod-diff19.2%
Applied egg-rr19.2%
add-exp-log19.2%
log-pow19.2%
Applied egg-rr19.2%
Final simplification19.2%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (pow (cbrt hi) 2.0)))
(sqrt
(pow
(+
1.0
(/
(+
x
(+
(fma (/ (- x hi) lo) hi (* (cbrt hi) (- t_0)))
(fma (- (cbrt hi)) t_0 (* (cbrt hi) t_0))))
lo))
2.0))))
double code(double lo, double hi, double x) {
double t_0 = pow(cbrt(hi), 2.0);
return sqrt(pow((1.0 + ((x + (fma(((x - hi) / lo), hi, (cbrt(hi) * -t_0)) + fma(-cbrt(hi), t_0, (cbrt(hi) * t_0)))) / lo)), 2.0));
}
function code(lo, hi, x) t_0 = cbrt(hi) ^ 2.0 return sqrt((Float64(1.0 + Float64(Float64(x + Float64(fma(Float64(Float64(x - hi) / lo), hi, Float64(cbrt(hi) * Float64(-t_0))) + fma(Float64(-cbrt(hi)), t_0, Float64(cbrt(hi) * t_0)))) / lo)) ^ 2.0)) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[Power[hi, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[(N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] * hi + N[(N[Power[hi, 1/3], $MachinePrecision] * (-t$95$0)), $MachinePrecision]), $MachinePrecision] + N[((-N[Power[hi, 1/3], $MachinePrecision]) * t$95$0 + N[(N[Power[hi, 1/3], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\sqrt[3]{hi}\right)}^{2}\\
\sqrt{{\left(1 + \frac{x + \left(\mathsf{fma}\left(\frac{x - hi}{lo}, hi, \sqrt[3]{hi} \cdot \left(-t\_0\right)\right) + \mathsf{fma}\left(-\sqrt[3]{hi}, t\_0, \sqrt[3]{hi} \cdot t\_0\right)\right)}{lo}\right)}^{2}}
\end{array}
\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.0%
Simplified15.0%
add-sqr-sqrt15.0%
sqrt-unprod15.0%
pow215.0%
Applied egg-rr19.2%
fmm-undef14.6%
*-commutative14.6%
add-cube-cbrt14.6%
prod-diff19.2%
pow219.2%
pow219.2%
pow219.2%
Applied egg-rr19.2%
Final simplification19.2%
(FPCore (lo hi x) :precision binary64 (sqrt (pow (+ 1.0 (/ (+ x (pow (cbrt (fma hi (/ (- x hi) lo) (- hi))) 3.0)) lo)) 2.0)))
double code(double lo, double hi, double x) {
return sqrt(pow((1.0 + ((x + pow(cbrt(fma(hi, ((x - hi) / lo), -hi)), 3.0)) / lo)), 2.0));
}
function code(lo, hi, x) return sqrt((Float64(1.0 + Float64(Float64(x + (cbrt(fma(hi, Float64(Float64(x - hi) / lo), Float64(-hi))) ^ 3.0)) / lo)) ^ 2.0)) end
code[lo_, hi_, x_] := N[Sqrt[N[Power[N[(1.0 + N[(N[(x + N[Power[N[Power[N[(hi * N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + (-hi)), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{{\left(1 + \frac{x + {\left(\sqrt[3]{\mathsf{fma}\left(hi, \frac{x - hi}{lo}, -hi\right)}\right)}^{3}}{lo}\right)}^{2}}
\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.0%
Simplified15.0%
add-sqr-sqrt15.0%
sqrt-unprod15.0%
pow215.0%
Applied egg-rr19.2%
*-un-lft-identity19.2%
add-cube-cbrt19.2%
unpow219.2%
frac-times19.2%
fmm-def14.6%
add-cube-cbrt14.6%
pow314.6%
Applied egg-rr19.2%
(FPCore (lo hi x) :precision binary64 (fabs (+ 1.0 (/ (fma hi (- -1.0 (/ (- hi x) lo)) x) lo))))
double code(double lo, double hi, double x) {
return fabs((1.0 + (fma(hi, (-1.0 - ((hi - x) / lo)), x) / lo)));
}
function code(lo, hi, x) return abs(Float64(1.0 + Float64(fma(hi, Float64(-1.0 - Float64(Float64(hi - x) / lo)), x) / lo))) end
code[lo_, hi_, x_] := N[Abs[N[(1.0 + N[(N[(hi * N[(-1.0 - N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|1 + \frac{\mathsf{fma}\left(hi, -1 - \frac{hi - x}{lo}, x\right)}{lo}\right|
\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.0%
Simplified15.0%
add-sqr-sqrt15.0%
sqrt-unprod15.0%
pow215.0%
Applied egg-rr19.2%
pow1/219.2%
Applied egg-rr19.2%
unpow1/219.2%
unpow219.2%
rem-sqrt-square19.2%
Simplified19.2%
Final simplification19.2%
(FPCore (lo hi x) :precision binary64 (- 1.0 (/ (- x (* hi (- (/ (- hi x) lo) -1.0))) lo)))
double code(double lo, double hi, double x) {
return 1.0 - ((x - (hi * (((hi - x) / 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 * (((hi - x) / lo) - (-1.0d0)))) / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 - ((x - (hi * (((hi - x) / lo) - -1.0))) / lo);
}
def code(lo, hi, x): return 1.0 - ((x - (hi * (((hi - x) / lo) - -1.0))) / lo)
function code(lo, hi, x) return Float64(1.0 - Float64(Float64(x - Float64(hi * Float64(Float64(Float64(hi - x) / lo) - -1.0))) / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 - ((x - (hi * (((hi - x) / lo) - -1.0))) / lo); end
code[lo_, hi_, x_] := N[(1.0 - N[(N[(x - N[(hi * N[(N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \frac{x - hi \cdot \left(\frac{hi - x}{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.0%
Simplified15.0%
Taylor expanded in hi around 0 18.9%
sub-neg18.9%
neg-mul-118.9%
+-commutative18.9%
sub-neg18.9%
div-sub18.9%
metadata-eval18.9%
Simplified18.9%
Final simplification18.9%
(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 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.9%
associate-*r/18.9%
neg-mul-118.9%
Simplified18.9%
(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 2024150
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))