
(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 5 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 (cbrt (fma (pow (/ lo hi) 2.0) 0.5 (/ lo hi)))))
(-
(/ x hi)
(log (+ 1.0 (- (* t_0 (pow t_0 2.0)) (* (/ x hi) (/ lo hi))))))))
double code(double lo, double hi, double x) {
double t_0 = cbrt(fma(pow((lo / hi), 2.0), 0.5, (lo / hi)));
return (x / hi) - log((1.0 + ((t_0 * pow(t_0, 2.0)) - ((x / hi) * (lo / hi)))));
}
function code(lo, hi, x) t_0 = cbrt(fma((Float64(lo / hi) ^ 2.0), 0.5, Float64(lo / hi))) return Float64(Float64(x / hi) - log(Float64(1.0 + Float64(Float64(t_0 * (t_0 ^ 2.0)) - Float64(Float64(x / hi) * Float64(lo / hi)))))) end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[(N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision] * 0.5 + N[(lo / hi), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(N[(x / hi), $MachinePrecision] - N[Log[N[(1.0 + N[(N[(t$95$0 * N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] - N[(N[(x / hi), $MachinePrecision] * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt[3]{\mathsf{fma}\left({\left(\frac{lo}{hi}\right)}^{2}, 0.5, \frac{lo}{hi}\right)}\\
\frac{x}{hi} - \log \left(1 + \left(t_0 \cdot {t_0}^{2} - \frac{x}{hi} \cdot \frac{lo}{hi}\right)\right)
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around 0 18.8%
mul-1-neg18.8%
unsub-neg18.8%
mul-1-neg18.8%
unsub-neg18.8%
unpow218.8%
Simplified18.8%
log1p-expm1-u18.8%
log1p-udef18.8%
inv-pow18.8%
div-inv18.8%
pow218.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate-+r+0.0%
mul-1-neg0.0%
unsub-neg0.0%
*-commutative0.0%
fma-def0.0%
unpow20.0%
unpow20.0%
times-frac11.5%
unpow211.5%
*-commutative11.5%
unpow211.5%
times-frac21.4%
Simplified21.4%
add-cube-cbrt21.4%
pow221.4%
Applied egg-rr21.4%
Final simplification21.4%
(FPCore (lo hi x)
:precision binary64
(-
(/ x hi)
(log
(+
1.0
(- (+ (/ lo hi) (* (pow (/ lo hi) 2.0) 0.5)) (* (/ x hi) (/ lo hi)))))))
double code(double lo, double hi, double x) {
return (x / hi) - log((1.0 + (((lo / hi) + (pow((lo / hi), 2.0) * 0.5)) - ((x / hi) * (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 / hi) - log((1.0d0 + (((lo / hi) + (((lo / hi) ** 2.0d0) * 0.5d0)) - ((x / hi) * (lo / hi)))))
end function
public static double code(double lo, double hi, double x) {
return (x / hi) - Math.log((1.0 + (((lo / hi) + (Math.pow((lo / hi), 2.0) * 0.5)) - ((x / hi) * (lo / hi)))));
}
def code(lo, hi, x): return (x / hi) - math.log((1.0 + (((lo / hi) + (math.pow((lo / hi), 2.0) * 0.5)) - ((x / hi) * (lo / hi)))))
function code(lo, hi, x) return Float64(Float64(x / hi) - log(Float64(1.0 + Float64(Float64(Float64(lo / hi) + Float64((Float64(lo / hi) ^ 2.0) * 0.5)) - Float64(Float64(x / hi) * Float64(lo / hi)))))) end
function tmp = code(lo, hi, x) tmp = (x / hi) - log((1.0 + (((lo / hi) + (((lo / hi) ^ 2.0) * 0.5)) - ((x / hi) * (lo / hi))))); end
code[lo_, hi_, x_] := N[(N[(x / hi), $MachinePrecision] - N[Log[N[(1.0 + N[(N[(N[(lo / hi), $MachinePrecision] + N[(N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] - N[(N[(x / hi), $MachinePrecision] * N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{hi} - \log \left(1 + \left(\left(\frac{lo}{hi} + {\left(\frac{lo}{hi}\right)}^{2} \cdot 0.5\right) - \frac{x}{hi} \cdot \frac{lo}{hi}\right)\right)
\end{array}
Initial program 3.1%
Taylor expanded in lo around 0 18.8%
mul-1-neg18.8%
unsub-neg18.8%
mul-1-neg18.8%
unsub-neg18.8%
unpow218.8%
Simplified18.8%
log1p-expm1-u18.8%
log1p-udef18.8%
inv-pow18.8%
div-inv18.8%
pow218.8%
pow-flip18.8%
metadata-eval18.8%
Applied egg-rr18.8%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate-+r+0.0%
mul-1-neg0.0%
unsub-neg0.0%
*-commutative0.0%
fma-def0.0%
unpow20.0%
unpow20.0%
times-frac11.5%
unpow211.5%
*-commutative11.5%
unpow211.5%
times-frac21.4%
Simplified21.4%
fma-udef21.4%
Applied egg-rr21.4%
Final simplification21.4%
(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 hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac9.4%
div-sub9.4%
Simplified9.4%
add-log-exp9.4%
fma-def9.4%
Applied egg-rr9.4%
Taylor expanded in hi around inf 20.6%
sub-neg20.6%
+-commutative20.6%
neg-mul-120.6%
associate-+l+20.6%
neg-mul-120.6%
sub-neg20.6%
div-sub20.6%
Simplified20.6%
Final simplification20.6%
(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%
mul-1-neg18.8%
unsub-neg18.8%
mul-1-neg18.8%
unsub-neg18.8%
unpow218.8%
Simplified18.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%
Final simplification18.7%
herbie shell --seed 2023213
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))