
(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
(let* ((t_0 (log1p (/ lo (- hi)))))
(cbrt
(expm1
(log1p
(fma
x
(*
3.0
(*
(pow t_0 2.0)
(+ (/ 1.0 hi) (/ (/ lo (pow hi 2.0)) (- 1.0 (/ lo hi))))))
(pow t_0 3.0)))))))
double code(double lo, double hi, double x) {
double t_0 = log1p((lo / -hi));
return cbrt(expm1(log1p(fma(x, (3.0 * (pow(t_0, 2.0) * ((1.0 / hi) + ((lo / pow(hi, 2.0)) / (1.0 - (lo / hi)))))), pow(t_0, 3.0)))));
}
function code(lo, hi, x) t_0 = log1p(Float64(lo / Float64(-hi))) return cbrt(expm1(log1p(fma(x, Float64(3.0 * Float64((t_0 ^ 2.0) * Float64(Float64(1.0 / hi) + Float64(Float64(lo / (hi ^ 2.0)) / Float64(1.0 - Float64(lo / hi)))))), (t_0 ^ 3.0))))) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Log[1 + N[(lo / (-hi)), $MachinePrecision]], $MachinePrecision]}, N[Power[N[(Exp[N[Log[1 + N[(x * N[(3.0 * N[(N[Power[t$95$0, 2.0], $MachinePrecision] * N[(N[(1.0 / hi), $MachinePrecision] + N[(N[(lo / N[Power[hi, 2.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[Power[t$95$0, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision], 1/3], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{log1p}\left(\frac{lo}{-hi}\right)\\
\sqrt[3]{\mathsf{expm1}\left(\mathsf{log1p}\left(\mathsf{fma}\left(x, 3 \cdot \left({t\_0}^{2} \cdot \left(\frac{1}{hi} + \frac{\frac{lo}{{hi}^{2}}}{1 - \frac{lo}{hi}}\right)\right), {t\_0}^{3}\right)\right)\right)}
\end{array}
\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%
add-exp-log18.8%
div-inv18.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
add-log-exp18.8%
*-commutative18.8%
rem-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in lo around 0 20.6%
*-commutative20.6%
Simplified20.6%
add-cbrt-cube20.6%
pow320.6%
Applied egg-rr20.6%
expm1-log1p-u20.6%
expm1-undefine20.6%
Applied egg-rr20.6%
expm1-define20.6%
fma-define20.6%
distribute-lft1-in20.6%
Simplified20.6%
add-log-exp20.6%
*-commutative20.6%
log-prod20.6%
add-log-exp20.6%
+-commutative20.6%
log1p-define20.6%
Applied egg-rr20.6%
Taylor expanded in x around 0 20.6%
fma-define20.6%
Simplified20.6%
Final simplification20.6%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (exp (/ x hi))))
(log
(*
lo
(pow
(cbrt (fma t_0 (+ (* x (pow hi -2.0)) (/ -1.0 hi)) (/ t_0 lo)))
3.0)))))
double code(double lo, double hi, double x) {
double t_0 = exp((x / hi));
return log((lo * pow(cbrt(fma(t_0, ((x * pow(hi, -2.0)) + (-1.0 / hi)), (t_0 / lo))), 3.0)));
}
function code(lo, hi, x) t_0 = exp(Float64(x / hi)) return log(Float64(lo * (cbrt(fma(t_0, Float64(Float64(x * (hi ^ -2.0)) + Float64(-1.0 / hi)), Float64(t_0 / lo))) ^ 3.0))) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Exp[N[(x / hi), $MachinePrecision]], $MachinePrecision]}, N[Log[N[(lo * N[Power[N[Power[N[(t$95$0 * N[(N[(x * N[Power[hi, -2.0], $MachinePrecision]), $MachinePrecision] + N[(-1.0 / hi), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 / lo), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{\frac{x}{hi}}\\
\log \left(lo \cdot {\left(\sqrt[3]{\mathsf{fma}\left(t\_0, x \cdot {hi}^{-2} + \frac{-1}{hi}, \frac{t\_0}{lo}\right)}\right)}^{3}\right)
\end{array}
\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%
add-exp-log18.8%
div-inv18.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
add-log-exp18.8%
*-commutative18.8%
rem-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in lo around 0 20.6%
*-commutative20.6%
Simplified20.6%
Taylor expanded in lo around inf 20.6%
add-cube-cbrt20.6%
pow320.6%
fma-define20.6%
div-inv20.6%
pow-flip20.6%
metadata-eval20.6%
Applied egg-rr20.6%
Final simplification20.6%
(FPCore (lo hi x) :precision binary64 (+ (log1p (/ lo (- hi))) (* x (+ (/ 1.0 hi) (/ (/ lo (pow hi 2.0)) (- 1.0 (/ lo hi)))))))
double code(double lo, double hi, double x) {
return log1p((lo / -hi)) + (x * ((1.0 / hi) + ((lo / pow(hi, 2.0)) / (1.0 - (lo / hi)))));
}
public static double code(double lo, double hi, double x) {
return Math.log1p((lo / -hi)) + (x * ((1.0 / hi) + ((lo / Math.pow(hi, 2.0)) / (1.0 - (lo / hi)))));
}
def code(lo, hi, x): return math.log1p((lo / -hi)) + (x * ((1.0 / hi) + ((lo / math.pow(hi, 2.0)) / (1.0 - (lo / hi)))))
function code(lo, hi, x) return Float64(log1p(Float64(lo / Float64(-hi))) + Float64(x * Float64(Float64(1.0 / hi) + Float64(Float64(lo / (hi ^ 2.0)) / Float64(1.0 - Float64(lo / hi)))))) end
code[lo_, hi_, x_] := N[(N[Log[1 + N[(lo / (-hi)), $MachinePrecision]], $MachinePrecision] + N[(x * N[(N[(1.0 / hi), $MachinePrecision] + N[(N[(lo / N[Power[hi, 2.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\frac{lo}{-hi}\right) + x \cdot \left(\frac{1}{hi} + \frac{\frac{lo}{{hi}^{2}}}{1 - \frac{lo}{hi}}\right)
\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%
add-exp-log18.8%
div-inv18.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
add-log-exp18.8%
*-commutative18.8%
rem-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in lo around 0 20.6%
*-commutative20.6%
Simplified20.6%
add-cbrt-cube20.6%
pow320.6%
Applied egg-rr20.6%
expm1-log1p-u20.6%
expm1-undefine20.6%
Applied egg-rr20.6%
expm1-define20.6%
fma-define20.6%
distribute-lft1-in20.6%
Simplified20.6%
add-log-exp20.6%
*-commutative20.6%
log-prod20.6%
add-log-exp20.6%
+-commutative20.6%
log1p-define20.6%
Applied egg-rr20.6%
Taylor expanded in x around 0 20.6%
log1p-define20.6%
associate-*r/20.6%
mul-1-neg20.6%
associate-/r*20.6%
mul-1-neg20.6%
unsub-neg20.6%
Simplified20.6%
Final simplification20.6%
(FPCore (lo hi x) :precision binary64 (log (+ 1.0 (/ (- x lo) hi))))
double code(double lo, double hi, double x) {
return log((1.0 + ((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 = log((1.0d0 + ((x - lo) / hi)))
end function
public static double code(double lo, double hi, double x) {
return Math.log((1.0 + ((x - lo) / hi)));
}
def code(lo, hi, x): return math.log((1.0 + ((x - lo) / hi)))
function code(lo, hi, x) return log(Float64(1.0 + Float64(Float64(x - lo) / hi))) end
function tmp = code(lo, hi, x) tmp = log((1.0 + ((x - lo) / hi))); end
code[lo_, hi_, x_] := N[Log[N[(1.0 + N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(1 + \frac{x - lo}{hi}\right)
\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%
add-exp-log18.8%
div-inv18.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
add-log-exp18.8%
*-commutative18.8%
rem-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in hi around inf 20.6%
associate--l+20.6%
div-sub20.6%
Simplified20.6%
(FPCore (lo hi x) :precision binary64 (log1p (/ lo (- hi))))
double code(double lo, double hi, double x) {
return log1p((lo / -hi));
}
public static double code(double lo, double hi, double x) {
return Math.log1p((lo / -hi));
}
def code(lo, hi, x): return math.log1p((lo / -hi))
function code(lo, hi, x) return log1p(Float64(lo / Float64(-hi))) end
code[lo_, hi_, x_] := N[Log[1 + N[(lo / (-hi)), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\frac{lo}{-hi}\right)
\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%
add-exp-log18.8%
div-inv18.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
add-log-exp18.8%
*-commutative18.8%
rem-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in lo around 0 20.6%
*-commutative20.6%
Simplified20.6%
Taylor expanded in x around 0 20.6%
log1p-define20.6%
mul-1-neg20.6%
distribute-neg-frac220.6%
Simplified20.6%
(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%
(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%
neg-mul-118.8%
distribute-neg-frac218.8%
Simplified18.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 2024105
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))