
(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 (+ 1.0 (/ (fabs (fma hi (/ (+ hi x) lo) hi)) lo)))
double code(double lo, double hi, double x) {
return 1.0 + (fabs(fma(hi, ((hi + x) / lo), hi)) / lo);
}
function code(lo, hi, x) return Float64(1.0 + Float64(abs(fma(hi, Float64(Float64(hi + x) / lo), hi)) / lo)) end
code[lo_, hi_, x_] := N[(1.0 + N[(N[Abs[N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + hi), $MachinePrecision]], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{\left|\mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi\right)\right|}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*14.3%
Simplified14.3%
expm1-log1p-u14.3%
expm1-undefine14.3%
add-sqr-sqrt5.4%
sqrt-unprod13.8%
sqr-neg13.8%
sqrt-unprod8.4%
add-sqr-sqrt13.0%
Applied egg-rr13.0%
expm1-define13.0%
associate-+r-13.0%
div-sub13.0%
associate-*r/0.0%
div-sub0.0%
associate-*r/13.0%
associate-+r-13.0%
fma-neg19.2%
Simplified19.2%
fma-neg13.0%
add-sqr-sqrt4.6%
sqrt-unprod0.0%
pow20.0%
fma-neg0.0%
sub-neg0.0%
add-sqr-sqrt0.0%
sqrt-unprod0.0%
sqr-neg0.0%
sqrt-unprod0.0%
add-sqr-sqrt0.0%
add-sqr-sqrt0.0%
sqrt-unprod0.0%
sqr-neg0.0%
sqrt-unprod0.0%
add-sqr-sqrt0.0%
Applied egg-rr0.0%
unpow20.0%
rem-sqrt-square19.7%
+-commutative19.7%
Simplified19.7%
Taylor expanded in x around 0 0.7%
associate-*r/13.8%
+-commutative13.8%
fma-define19.7%
Simplified19.7%
Final simplification19.7%
(FPCore (lo hi x) :precision binary64 (- 1.0 (/ (+ x (fma hi (/ (+ hi x) lo) hi)) lo)))
double code(double lo, double hi, double x) {
return 1.0 - ((x + fma(hi, ((hi + x) / lo), hi)) / lo);
}
function code(lo, hi, x) return Float64(1.0 - Float64(Float64(x + fma(hi, Float64(Float64(hi + x) / lo), hi)) / lo)) end
code[lo_, hi_, x_] := N[(1.0 - N[(N[(x + N[(hi * N[(N[(hi + x), $MachinePrecision] / lo), $MachinePrecision] + hi), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \frac{x + \mathsf{fma}\left(hi, \frac{hi + x}{lo}, hi\right)}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*14.3%
Simplified14.3%
expm1-log1p-u14.3%
expm1-undefine14.3%
add-sqr-sqrt5.4%
sqrt-unprod13.8%
sqr-neg13.8%
sqrt-unprod8.4%
add-sqr-sqrt13.0%
Applied egg-rr13.0%
expm1-define13.0%
associate-+r-13.0%
div-sub13.0%
associate-*r/0.0%
div-sub0.0%
associate-*r/13.0%
associate-+r-13.0%
fma-neg19.2%
Simplified19.2%
expm1-log1p-u19.2%
div-inv19.2%
fma-neg13.2%
rem-cube-cbrt13.2%
rem-cube-cbrt13.2%
add-sqr-sqrt8.4%
sqrt-unprod13.8%
sqr-neg13.8%
sqrt-unprod5.4%
Applied egg-rr19.2%
Final simplification19.2%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (/ (+ x (* hi (+ (/ (- x hi) lo) -1.0))) lo)))
double code(double lo, double hi, double x) {
return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.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 = 1.0d0 + ((x + (hi * (((x - hi) / lo) + (-1.0d0)))) / lo)
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo);
}
def code(lo, hi, x): return 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo)
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(x + Float64(hi * Float64(Float64(Float64(x - hi) / lo) + -1.0))) / lo)) end
function tmp = code(lo, hi, x) tmp = 1.0 + ((x + (hi * (((x - hi) / lo) + -1.0))) / lo); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(x + N[(hi * N[(N[(N[(x - hi), $MachinePrecision] / lo), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{x + hi \cdot \left(\frac{x - hi}{lo} + -1\right)}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around -inf 3.1%
mul-1-neg3.1%
associate--l+3.1%
associate-/l*14.3%
Simplified14.3%
unsub-neg14.3%
add-sqr-sqrt8.9%
sqrt-unprod13.7%
sqr-neg13.7%
sqrt-unprod4.8%
add-sqr-sqrt13.2%
expm1-log1p-u13.0%
add-sqr-sqrt4.6%
sqrt-unprod13.5%
Applied egg-rr13.0%
expm1-log1p-u13.2%
Applied egg-rr13.2%
sub-neg13.2%
neg-mul-113.2%
*-commutative13.2%
distribute-lft-in19.2%
Simplified19.2%
Final simplification19.2%
(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)))