
(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 (/ x (pow lo 2.0))))
(-
(* hi (- (+ (/ 1.0 lo) (/ (* hi (- (/ 1.0 lo) t_0)) lo)) t_0))
(/ (pow (pow (- x lo) 0.16666666666666666) 6.0) lo))))
double code(double lo, double hi, double x) {
double t_0 = x / pow(lo, 2.0);
return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (pow(pow((x - lo), 0.16666666666666666), 6.0) / lo);
}
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 = x / (lo ** 2.0d0)
code = (hi * (((1.0d0 / lo) + ((hi * ((1.0d0 / lo) - t_0)) / lo)) - t_0)) - ((((x - lo) ** 0.16666666666666666d0) ** 6.0d0) / lo)
end function
public static double code(double lo, double hi, double x) {
double t_0 = x / Math.pow(lo, 2.0);
return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (Math.pow(Math.pow((x - lo), 0.16666666666666666), 6.0) / lo);
}
def code(lo, hi, x): t_0 = x / math.pow(lo, 2.0) return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (math.pow(math.pow((x - lo), 0.16666666666666666), 6.0) / lo)
function code(lo, hi, x) t_0 = Float64(x / (lo ^ 2.0)) return Float64(Float64(hi * Float64(Float64(Float64(1.0 / lo) + Float64(Float64(hi * Float64(Float64(1.0 / lo) - t_0)) / lo)) - t_0)) - Float64(((Float64(x - lo) ^ 0.16666666666666666) ^ 6.0) / lo)) end
function tmp = code(lo, hi, x) t_0 = x / (lo ^ 2.0); tmp = (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - ((((x - lo) ^ 0.16666666666666666) ^ 6.0) / lo); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]}, N[(N[(hi * N[(N[(N[(1.0 / lo), $MachinePrecision] + N[(N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] - N[(N[Power[N[Power[N[(x - lo), $MachinePrecision], 0.16666666666666666], $MachinePrecision], 6.0], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{{lo}^{2}}\\
hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - t\_0\right)}{lo}\right) - t\_0\right) - \frac{{\left({\left(x - lo\right)}^{0.16666666666666666}\right)}^{6}}{lo}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in hi around 0 19.0%
add-exp-log19.0%
Applied egg-rr19.0%
rem-exp-log19.0%
rem-cube-cbrt19.0%
add-sqr-sqrt19.0%
unpow-prod-down19.0%
pow1/319.0%
sqrt-pow119.0%
metadata-eval19.0%
pow1/319.0%
sqrt-pow119.0%
metadata-eval19.0%
Applied egg-rr19.0%
pow-prod-up19.0%
metadata-eval19.0%
Applied egg-rr19.0%
Final simplification19.0%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ x (pow lo 2.0))))
(-
(* hi (- (+ (/ 1.0 lo) (/ (* hi (- (/ 1.0 lo) t_0)) lo)) t_0))
(/ (exp (* (log (pow (- x lo) 0.16666666666666666)) 6.0)) lo))))
double code(double lo, double hi, double x) {
double t_0 = x / pow(lo, 2.0);
return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (exp((log(pow((x - lo), 0.16666666666666666)) * 6.0)) / lo);
}
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 = x / (lo ** 2.0d0)
code = (hi * (((1.0d0 / lo) + ((hi * ((1.0d0 / lo) - t_0)) / lo)) - t_0)) - (exp((log(((x - lo) ** 0.16666666666666666d0)) * 6.0d0)) / lo)
end function
public static double code(double lo, double hi, double x) {
double t_0 = x / Math.pow(lo, 2.0);
return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (Math.exp((Math.log(Math.pow((x - lo), 0.16666666666666666)) * 6.0)) / lo);
}
def code(lo, hi, x): t_0 = x / math.pow(lo, 2.0) return (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (math.exp((math.log(math.pow((x - lo), 0.16666666666666666)) * 6.0)) / lo)
function code(lo, hi, x) t_0 = Float64(x / (lo ^ 2.0)) return Float64(Float64(hi * Float64(Float64(Float64(1.0 / lo) + Float64(Float64(hi * Float64(Float64(1.0 / lo) - t_0)) / lo)) - t_0)) - Float64(exp(Float64(log((Float64(x - lo) ^ 0.16666666666666666)) * 6.0)) / lo)) end
function tmp = code(lo, hi, x) t_0 = x / (lo ^ 2.0); tmp = (hi * (((1.0 / lo) + ((hi * ((1.0 / lo) - t_0)) / lo)) - t_0)) - (exp((log(((x - lo) ^ 0.16666666666666666)) * 6.0)) / lo); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision]}, N[(N[(hi * N[(N[(N[(1.0 / lo), $MachinePrecision] + N[(N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] - N[(N[Exp[N[(N[Log[N[Power[N[(x - lo), $MachinePrecision], 0.16666666666666666], $MachinePrecision]], $MachinePrecision] * 6.0), $MachinePrecision]], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{{lo}^{2}}\\
hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - t\_0\right)}{lo}\right) - t\_0\right) - \frac{e^{\log \left({\left(x - lo\right)}^{0.16666666666666666}\right) \cdot 6}}{lo}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in hi around 0 19.0%
add-exp-log19.0%
Applied egg-rr19.0%
rem-exp-log19.0%
rem-cube-cbrt19.0%
add-sqr-sqrt19.0%
unpow-prod-down19.0%
pow1/319.0%
sqrt-pow119.0%
metadata-eval19.0%
pow1/319.0%
sqrt-pow119.0%
metadata-eval19.0%
Applied egg-rr19.0%
pow-prod-up19.0%
pow-to-exp19.0%
metadata-eval19.0%
Applied egg-rr19.0%
Final simplification19.0%
(FPCore (lo hi x)
:precision binary64
(-
(/ (- lo x) lo)
(*
hi
(+
(/ x (pow lo 2.0))
(-
(/ -1.0 lo)
(exp (log (/ (* hi (- (/ 1.0 lo) (* x (pow lo -2.0)))) lo))))))))
double code(double lo, double hi, double x) {
return ((lo - x) / lo) - (hi * ((x / pow(lo, 2.0)) + ((-1.0 / lo) - exp(log(((hi * ((1.0 / lo) - (x * pow(lo, -2.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 = ((lo - x) / lo) - (hi * ((x / (lo ** 2.0d0)) + (((-1.0d0) / lo) - exp(log(((hi * ((1.0d0 / lo) - (x * (lo ** (-2.0d0))))) / lo))))))
end function
public static double code(double lo, double hi, double x) {
return ((lo - x) / lo) - (hi * ((x / Math.pow(lo, 2.0)) + ((-1.0 / lo) - Math.exp(Math.log(((hi * ((1.0 / lo) - (x * Math.pow(lo, -2.0)))) / lo))))));
}
def code(lo, hi, x): return ((lo - x) / lo) - (hi * ((x / math.pow(lo, 2.0)) + ((-1.0 / lo) - math.exp(math.log(((hi * ((1.0 / lo) - (x * math.pow(lo, -2.0)))) / lo))))))
function code(lo, hi, x) return Float64(Float64(Float64(lo - x) / lo) - Float64(hi * Float64(Float64(x / (lo ^ 2.0)) + Float64(Float64(-1.0 / lo) - exp(log(Float64(Float64(hi * Float64(Float64(1.0 / lo) - Float64(x * (lo ^ -2.0)))) / lo))))))) end
function tmp = code(lo, hi, x) tmp = ((lo - x) / lo) - (hi * ((x / (lo ^ 2.0)) + ((-1.0 / lo) - exp(log(((hi * ((1.0 / lo) - (x * (lo ^ -2.0)))) / lo)))))); end
code[lo_, hi_, x_] := N[(N[(N[(lo - x), $MachinePrecision] / lo), $MachinePrecision] - N[(hi * N[(N[(x / N[Power[lo, 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-1.0 / lo), $MachinePrecision] - N[Exp[N[Log[N[(N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - N[(x * N[Power[lo, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{lo - x}{lo} - hi \cdot \left(\frac{x}{{lo}^{2}} + \left(\frac{-1}{lo} - e^{\log \left(\frac{hi \cdot \left(\frac{1}{lo} - x \cdot {lo}^{-2}\right)}{lo}\right)}\right)\right)
\end{array}
Initial program 3.1%
Taylor expanded in hi around 0 19.0%
add-exp-log19.0%
div-inv19.0%
pow-flip19.0%
metadata-eval19.0%
Applied egg-rr19.0%
Final simplification19.0%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ -1.0 (/ lo (fma hi (- -1.0 (/ hi lo)) x)))))
double code(double lo, double hi, double x) {
return 1.0 + (-1.0 / (lo / fma(hi, (-1.0 - (hi / lo)), x)));
}
function code(lo, hi, x) return Float64(1.0 + Float64(-1.0 / Float64(lo / fma(hi, Float64(-1.0 - Float64(hi / lo)), x)))) end
code[lo_, hi_, x_] := N[(1.0 + N[(-1.0 / N[(lo / N[(hi * N[(-1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{-1}{\frac{lo}{\mathsf{fma}\left(hi, -1 - \frac{hi}{lo}, x\right)}}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
unsub-neg3.1%
+-commutative3.1%
associate-/l*14.8%
fma-define14.8%
Simplified14.8%
clear-num14.8%
inv-pow14.8%
Applied egg-rr14.8%
unpow-114.8%
fma-define14.8%
associate-*r/3.1%
+-commutative3.1%
associate--l+3.1%
sub-neg3.1%
associate-*r/14.8%
neg-mul-114.8%
*-commutative14.8%
distribute-lft-in18.9%
div-sub18.9%
sub-neg18.9%
mul-1-neg18.9%
+-commutative18.9%
metadata-eval18.9%
sub-neg18.9%
+-commutative18.9%
fma-define18.9%
Simplified18.9%
Taylor expanded in x around 0 19.0%
mul-1-neg19.0%
distribute-neg-frac219.0%
Simplified19.0%
Final simplification19.0%
(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%
unsub-neg3.1%
+-commutative3.1%
associate-/l*14.8%
fma-define14.8%
Simplified14.8%
clear-num14.8%
inv-pow14.8%
Applied egg-rr14.8%
unpow-114.8%
fma-define14.8%
associate-*r/3.1%
+-commutative3.1%
associate--l+3.1%
sub-neg3.1%
associate-*r/14.8%
neg-mul-114.8%
*-commutative14.8%
distribute-lft-in18.9%
div-sub18.9%
sub-neg18.9%
mul-1-neg18.9%
+-commutative18.9%
metadata-eval18.9%
sub-neg18.9%
+-commutative18.9%
fma-define18.9%
Simplified18.9%
Taylor expanded in x around 0 18.9%
mul-1-neg18.9%
Simplified18.9%
Final simplification18.9%
(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 hi around inf 18.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 2024114
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))