
(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 8 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
(cbrt
(pow
(+
1.0
(/
(pow
(expm1 (log1p (pow (cbrt (fma hi (/ (+ hi x) lo) (+ hi x))) 2.0)))
1.5)
lo))
3.0)))
double code(double lo, double hi, double x) {
return cbrt(pow((1.0 + (pow(expm1(log1p(pow(cbrt(fma(hi, ((hi + x) / lo), (hi + x))), 2.0))), 1.5) / lo)), 3.0));
}
function code(lo, hi, x) return cbrt((Float64(1.0 + Float64((expm1(log1p((cbrt(fma(hi, Float64(Float64(hi + x) / lo), Float64(hi + x))) ^ 2.0))) ^ 1.5) / lo)) ^ 3.0)) end
code[lo_, hi_, x_] := N[Power[N[Power[N[(1.0 + N[(N[Power[N[(Exp[N[Log[1 + N[Power[N[Power[N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + N[(hi + x), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision], 1.5], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]
\begin{array}{l}
\\
\sqrt[3]{{\left(1 + \frac{{\left(\mathsf{expm1}\left(\mathsf{log1p}\left({\left(\sqrt[3]{\mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi + x\right)}\right)}^{2}\right)\right)\right)}^{1.5}}{lo}\right)}^{3}}
\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.7%
Simplified14.7%
add-cbrt-cube14.7%
pow314.7%
Applied egg-rr18.8%
rem-cube-cbrt18.8%
sqr-pow9.2%
pow-prod-down19.6%
pow219.6%
metadata-eval19.6%
Applied egg-rr19.6%
fma-define14.2%
associate-+l+14.2%
+-commutative14.2%
associate-+r+14.2%
+-commutative14.2%
fma-undefine19.6%
+-commutative19.6%
Simplified19.6%
expm1-log1p-u19.6%
Applied egg-rr19.6%
(FPCore (lo hi x) :precision binary64 (cbrt (pow (+ 1.0 (/ (pow (pow (cbrt (fma hi (/ (+ hi x) lo) (+ hi x))) 2.0) 1.5) lo)) 3.0)))
double code(double lo, double hi, double x) {
return cbrt(pow((1.0 + (pow(pow(cbrt(fma(hi, ((hi + x) / lo), (hi + x))), 2.0), 1.5) / lo)), 3.0));
}
function code(lo, hi, x) return cbrt((Float64(1.0 + Float64(((cbrt(fma(hi, Float64(Float64(hi + x) / lo), Float64(hi + x))) ^ 2.0) ^ 1.5) / lo)) ^ 3.0)) end
code[lo_, hi_, x_] := N[Power[N[Power[N[(1.0 + N[(N[Power[N[Power[N[Power[N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + N[(hi + x), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 2.0], $MachinePrecision], 1.5], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]
\begin{array}{l}
\\
\sqrt[3]{{\left(1 + \frac{{\left({\left(\sqrt[3]{\mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi + x\right)}\right)}^{2}\right)}^{1.5}}{lo}\right)}^{3}}
\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.7%
Simplified14.7%
add-cbrt-cube14.7%
pow314.7%
Applied egg-rr18.8%
rem-cube-cbrt18.8%
sqr-pow9.2%
pow-prod-down19.6%
pow219.6%
metadata-eval19.6%
Applied egg-rr19.6%
fma-define14.2%
associate-+l+14.2%
+-commutative14.2%
associate-+r+14.2%
+-commutative14.2%
fma-undefine19.6%
+-commutative19.6%
Simplified19.6%
(FPCore (lo hi x) :precision binary64 (fma (+ x (fabs (fma hi (/ (+ hi x) lo) hi))) (/ 1.0 lo) 1.0))
double code(double lo, double hi, double x) {
return fma((x + fabs(fma(hi, ((hi + x) / lo), hi))), (1.0 / lo), 1.0);
}
function code(lo, hi, x) return fma(Float64(x + abs(fma(hi, Float64(Float64(hi + x) / lo), hi))), Float64(1.0 / lo), 1.0) end
code[lo_, hi_, x_] := N[(N[(x + N[Abs[N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + hi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 / lo), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x + \left|\mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi\right)\right|, \frac{1}{lo}, 1\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*14.7%
Simplified14.7%
add-cube-cbrt14.7%
pow314.7%
fmm-def18.8%
add-sqr-sqrt0.0%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-prod4.1%
add-sqr-sqrt4.1%
sub-neg4.1%
add-sqr-sqrt0.0%
sqrt-unprod0.7%
sqr-neg0.7%
sqrt-prod19.0%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
+-commutative19.0%
rem-cube-cbrt19.0%
distribute-neg-frac219.0%
add-sqr-sqrt19.0%
sqrt-unprod18.7%
sqr-neg18.7%
sqrt-unprod0.0%
add-sqr-sqrt18.8%
div-inv18.8%
fma-define18.8%
Applied egg-rr18.8%
add-sqr-sqrt9.2%
sqrt-unprod0.7%
pow20.7%
Applied egg-rr0.7%
unpow20.7%
rem-sqrt-square19.6%
+-commutative19.6%
Simplified19.6%
(FPCore (lo hi x) :precision binary64 (pow (/ hi lo) 2.0))
double code(double lo, double hi, double x) {
return pow((hi / 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
code = (hi / lo) ** 2.0d0
end function
public static double code(double lo, double hi, double x) {
return Math.pow((hi / lo), 2.0);
}
def code(lo, hi, x): return math.pow((hi / lo), 2.0)
function code(lo, hi, x) return Float64(hi / lo) ^ 2.0 end
function tmp = code(lo, hi, x) tmp = (hi / lo) ^ 2.0; end
code[lo_, hi_, x_] := N[Power[N[(hi / lo), $MachinePrecision], 2.0], $MachinePrecision]
\begin{array}{l}
\\
{\left(\frac{hi}{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*14.7%
Simplified14.7%
add-cbrt-cube14.7%
pow314.7%
Applied egg-rr18.8%
rem-cube-cbrt18.8%
sqr-pow9.2%
pow-prod-down19.6%
pow219.6%
metadata-eval19.6%
Applied egg-rr19.6%
fma-define14.2%
associate-+l+14.2%
+-commutative14.2%
associate-+r+14.2%
+-commutative14.2%
fma-undefine19.6%
+-commutative19.6%
Simplified19.6%
Taylor expanded in hi around inf 0.0%
unpow20.0%
unpow20.0%
times-frac19.2%
unpow219.2%
Simplified19.2%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (- (* hi (- -1.0 (+ (/ hi lo) (/ x lo)))) x) lo)))
double code(double lo, double hi, double x) {
return 1.0 + (((hi * (-1.0 - ((hi / lo) + (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 + (((hi * ((-1.0d0) - ((hi / lo) + (x / lo)))) - x) / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 + (((hi * (-1.0 - ((hi / lo) + (x / lo)))) - x) / lo);
}
def code(lo, hi, x): return 1.0 + (((hi * (-1.0 - ((hi / lo) + (x / lo)))) - x) / lo)
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(Float64(hi * Float64(-1.0 - Float64(Float64(hi / lo) + Float64(x / lo)))) - x) / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 + (((hi * (-1.0 - ((hi / lo) + (x / lo)))) - x) / lo); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(N[(hi * N[(-1.0 - N[(N[(hi / lo), $MachinePrecision] + N[(x / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{hi \cdot \left(-1 - \left(\frac{hi}{lo} + \frac{x}{lo}\right)\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.7%
Simplified14.7%
unsub-neg14.7%
fmm-def18.8%
add-sqr-sqrt0.0%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-prod4.1%
add-sqr-sqrt4.1%
sub-neg4.1%
add-sqr-sqrt0.0%
sqrt-unprod0.7%
sqr-neg0.7%
sqrt-prod19.0%
add-sqr-sqrt19.0%
Applied egg-rr19.0%
Taylor expanded in hi around 0 19.0%
Final simplification19.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*14.7%
Simplified14.7%
Taylor expanded in hi around 0 18.8%
sub-neg18.8%
+-commutative18.8%
mul-1-neg18.8%
sub-neg18.8%
div-sub18.8%
metadata-eval18.8%
Simplified18.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.7%
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 2024149
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))