
(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 (expm1 (- (* -0.5 (pow (/ hi lo) 2.0)) (* hi (fma -0.5 (* (/ x (* lo lo)) -4.0) (/ 1.0 lo))))))
double code(double lo, double hi, double x) {
return expm1(((-0.5 * pow((hi / lo), 2.0)) - (hi * fma(-0.5, ((x / (lo * lo)) * -4.0), (1.0 / lo)))));
}
function code(lo, hi, x) return expm1(Float64(Float64(-0.5 * (Float64(hi / lo) ^ 2.0)) - Float64(hi * fma(-0.5, Float64(Float64(x / Float64(lo * lo)) * -4.0), Float64(1.0 / lo))))) end
code[lo_, hi_, x_] := N[(Exp[N[(N[(-0.5 * N[Power[N[(hi / lo), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - N[(hi * N[(-0.5 * N[(N[(x / N[(lo * lo), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision] + N[(1.0 / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{expm1}\left(-0.5 \cdot {\left(\frac{hi}{lo}\right)}^{2} - hi \cdot \mathsf{fma}\left(-0.5, \frac{x}{lo \cdot lo} \cdot -4, \frac{1}{lo}\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%
expm1-log1p-u18.8%
associate-/r*18.8%
sub-div18.8%
Applied egg-rr18.8%
Taylor expanded in lo around -inf 0.0%
fma-def0.0%
unpow20.0%
times-frac0.0%
+-commutative0.0%
unpow20.0%
times-frac19.6%
+-commutative19.6%
Simplified19.6%
Taylor expanded in hi around -inf 0.0%
+-commutative0.0%
mul-1-neg0.0%
unsub-neg0.0%
unpow20.0%
unpow20.0%
times-frac22.2%
unpow222.2%
*-commutative22.2%
fma-def22.2%
distribute-rgt-out--22.2%
unpow222.2%
metadata-eval22.2%
Simplified22.2%
Final simplification22.2%
(FPCore (lo hi x) :precision binary64 (pow (/ lo hi) 2.0))
double code(double lo, double hi, double x) {
return pow((lo / hi), 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 = (lo / hi) ** 2.0d0
end function
public static double code(double lo, double hi, double x) {
return Math.pow((lo / hi), 2.0);
}
def code(lo, hi, x): return math.pow((lo / hi), 2.0)
function code(lo, hi, x) return Float64(lo / hi) ^ 2.0 end
function tmp = code(lo, hi, x) tmp = (lo / hi) ^ 2.0; end
code[lo_, hi_, x_] := N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision]
\begin{array}{l}
\\
{\left(\frac{lo}{hi}\right)}^{2}
\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.2%
div-sub9.2%
Simplified9.2%
Taylor expanded in x around 0 0.0%
sub-neg0.0%
+-commutative0.0%
mul-1-neg0.0%
unsub-neg0.0%
distribute-neg-frac0.0%
unpow20.0%
unpow20.0%
times-frac9.2%
Simplified9.2%
*-un-lft-identity9.2%
*-un-lft-identity9.2%
prod-diff9.2%
add-sqr-sqrt9.2%
sqrt-unprod3.1%
sqr-neg3.1%
sqrt-unprod0.0%
add-sqr-sqrt1.6%
pow21.6%
Applied egg-rr10.3%
+-commutative10.3%
fma-udef10.3%
*-rgt-identity10.3%
*-rgt-identity10.3%
count-210.3%
fma-udef10.3%
*-lft-identity10.3%
distribute-lft-neg-in10.3%
cancel-sign-sub-inv10.3%
*-rgt-identity10.3%
Simplified10.3%
Taylor expanded in lo around inf 0.0%
unpow20.0%
unpow20.0%
times-frac19.2%
unpow219.2%
Simplified19.2%
Final simplification19.2%
(FPCore (lo hi x) :precision binary64 (+ (+ 1.0 (/ (- x (* lo (- 1.0 (/ x hi)))) hi)) -1.0))
double code(double lo, double hi, double x) {
return (1.0 + ((x - (lo * (1.0 - (x / hi)))) / hi)) + -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 + ((x - (lo * (1.0d0 - (x / hi)))) / hi)) + (-1.0d0)
end function
public static double code(double lo, double hi, double x) {
return (1.0 + ((x - (lo * (1.0 - (x / hi)))) / hi)) + -1.0;
}
def code(lo, hi, x): return (1.0 + ((x - (lo * (1.0 - (x / hi)))) / hi)) + -1.0
function code(lo, hi, x) return Float64(Float64(1.0 + Float64(Float64(x - Float64(lo * Float64(1.0 - Float64(x / hi)))) / hi)) + -1.0) end
function tmp = code(lo, hi, x) tmp = (1.0 + ((x - (lo * (1.0 - (x / hi)))) / hi)) + -1.0; end
code[lo_, hi_, x_] := N[(N[(1.0 + N[(N[(x - N[(lo * N[(1.0 - N[(x / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]
\begin{array}{l}
\\
\left(1 + \frac{x - lo \cdot \left(1 - \frac{x}{hi}\right)}{hi}\right) + -1
\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%
expm1-log1p-u18.8%
associate-/r*18.8%
sub-div18.8%
Applied egg-rr18.8%
expm1-udef18.8%
log1p-udef18.8%
add-exp-log18.8%
associate-*r/18.8%
sub-div18.8%
Applied egg-rr18.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%
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%
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%
Final simplification18.7%
herbie shell --seed 2023215
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))