
(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 6 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
(log1p
(fabs
(fma
0.16666666666666666
(pow (/ (+ lo x) hi) 3.0)
(+ (fma 0.5 (pow (/ hi (+ lo x)) -2.0) (/ lo hi)) (/ x hi))))))
double code(double lo, double hi, double x) {
return log1p(fabs(fma(0.16666666666666666, pow(((lo + x) / hi), 3.0), (fma(0.5, pow((hi / (lo + x)), -2.0), (lo / hi)) + (x / hi)))));
}
function code(lo, hi, x) return log1p(abs(fma(0.16666666666666666, (Float64(Float64(lo + x) / hi) ^ 3.0), Float64(fma(0.5, (Float64(hi / Float64(lo + x)) ^ -2.0), Float64(lo / hi)) + Float64(x / hi))))) end
code[lo_, hi_, x_] := N[Log[1 + N[Abs[N[(0.16666666666666666 * N[Power[N[(N[(lo + x), $MachinePrecision] / hi), $MachinePrecision], 3.0], $MachinePrecision] + N[(N[(0.5 * N[Power[N[(hi / N[(lo + x), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] + N[(lo / hi), $MachinePrecision]), $MachinePrecision] + N[(x / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\left|\mathsf{fma}\left(0.16666666666666666, {\left(\frac{lo + x}{hi}\right)}^{3}, \mathsf{fma}\left(0.5, {\left(\frac{hi}{lo + x}\right)}^{-2}, \frac{lo}{hi}\right) + \frac{x}{hi}\right)\right|\right)
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
log1p-expm1-u18.8%
Applied egg-rr18.8%
add-sqr-sqrt18.8%
sqrt-unprod18.8%
pow218.8%
expm1-log1p-u18.8%
log1p-expm1-u18.8%
sub-neg18.8%
add-sqr-sqrt18.8%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-unprod0.0%
add-sqr-sqrt26.8%
Applied egg-rr26.8%
unpow226.8%
rem-sqrt-square26.8%
+-commutative26.8%
Simplified26.8%
Taylor expanded in hi around inf 0.0%
fma-def0.0%
cube-div0.0%
associate-+r+0.0%
fma-def0.0%
unpow20.0%
unpow20.0%
times-frac26.9%
*-lft-identity26.9%
associate-*l/26.9%
associate-/r/26.9%
unpow-126.9%
*-lft-identity26.9%
associate-*l/26.9%
associate-/r/26.9%
unpow-126.9%
pow-sqr26.9%
metadata-eval26.9%
Simplified26.9%
Final simplification26.9%
(FPCore (lo hi x) :precision binary64 (log1p (fabs (expm1 (/ (+ lo (fabs x)) hi)))))
double code(double lo, double hi, double x) {
return log1p(fabs(expm1(((lo + fabs(x)) / hi))));
}
public static double code(double lo, double hi, double x) {
return Math.log1p(Math.abs(Math.expm1(((lo + Math.abs(x)) / hi))));
}
def code(lo, hi, x): return math.log1p(math.fabs(math.expm1(((lo + math.fabs(x)) / hi))))
function code(lo, hi, x) return log1p(abs(expm1(Float64(Float64(lo + abs(x)) / hi)))) end
code[lo_, hi_, x_] := N[Log[1 + N[Abs[N[(Exp[N[(N[(lo + N[Abs[x], $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\left|\mathsf{expm1}\left(\frac{lo + \left|x\right|}{hi}\right)\right|\right)
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
log1p-expm1-u18.8%
Applied egg-rr18.8%
add-sqr-sqrt18.8%
sqrt-unprod18.8%
pow218.8%
expm1-log1p-u18.8%
log1p-expm1-u18.8%
sub-neg18.8%
add-sqr-sqrt18.8%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-unprod0.0%
add-sqr-sqrt26.8%
Applied egg-rr26.8%
unpow226.8%
rem-sqrt-square26.8%
+-commutative26.8%
Simplified26.8%
add-sqr-sqrt14.2%
sqrt-unprod20.4%
pow220.4%
Applied egg-rr20.4%
unpow220.4%
rem-sqrt-square26.8%
Simplified26.8%
Final simplification26.8%
(FPCore (lo hi x) :precision binary64 (log1p (fabs (expm1 (/ lo hi)))))
double code(double lo, double hi, double x) {
return log1p(fabs(expm1((lo / hi))));
}
public static double code(double lo, double hi, double x) {
return Math.log1p(Math.abs(Math.expm1((lo / hi))));
}
def code(lo, hi, x): return math.log1p(math.fabs(math.expm1((lo / hi))))
function code(lo, hi, x) return log1p(abs(expm1(Float64(lo / hi)))) end
code[lo_, hi_, x_] := N[Log[1 + N[Abs[N[(Exp[N[(lo / hi), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\left|\mathsf{expm1}\left(\frac{lo}{hi}\right)\right|\right)
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
log1p-expm1-u18.8%
Applied egg-rr18.8%
add-sqr-sqrt18.8%
sqrt-unprod18.8%
pow218.8%
expm1-log1p-u18.8%
log1p-expm1-u18.8%
sub-neg18.8%
add-sqr-sqrt18.8%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-unprod0.0%
add-sqr-sqrt26.8%
Applied egg-rr26.8%
unpow226.8%
rem-sqrt-square26.8%
+-commutative26.8%
Simplified26.8%
Taylor expanded in x around 0 26.8%
expm1-def26.8%
Simplified26.8%
Final simplification26.8%
(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%
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(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.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.6%
Final simplification18.6%
herbie shell --seed 2024075
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))