
(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 (* (/ x lo) (/ x lo))) (- 1.0 (fma hi (- (/ 1.0 lo) (/ x (* lo lo))) (/ (- x) lo)))))
double code(double lo, double hi, double x) {
return (1.0 - ((x / lo) * (x / lo))) / (1.0 - fma(hi, ((1.0 / lo) - (x / (lo * lo))), (-x / lo)));
}
function code(lo, hi, x) return Float64(Float64(1.0 - Float64(Float64(x / lo) * Float64(x / lo))) / Float64(1.0 - fma(hi, Float64(Float64(1.0 / lo) - Float64(x / Float64(lo * lo))), Float64(Float64(-x) / lo)))) end
code[lo_, hi_, x_] := N[(N[(1.0 - N[(N[(x / lo), $MachinePrecision] * N[(x / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - N[(x / N[(lo * lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[((-x) / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1 - \frac{x}{lo} \cdot \frac{x}{lo}}{1 - \mathsf{fma}\left(hi, \frac{1}{lo} - \frac{x}{lo \cdot lo}, \frac{-x}{lo}\right)}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.8%
distribute-lft-out--18.8%
associate-*r/18.8%
fma-neg18.8%
Simplified18.8%
flip-+18.8%
metadata-eval18.8%
Applied egg-rr18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
Simplified18.8%
Taylor expanded in hi around 0 26.5%
+-commutative26.5%
fma-def26.5%
+-commutative26.5%
mul-1-neg26.5%
unsub-neg26.5%
unpow226.5%
mul-1-neg26.5%
Simplified26.5%
Taylor expanded in hi around 0 74.3%
unpow274.3%
unpow274.3%
times-frac97.5%
Simplified97.5%
Final simplification97.5%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- hi x) lo)) (t_1 (* (+ 1.0 (/ hi lo)) t_0))) (/ (- 1.0 (* t_1 t_1)) (- 1.0 t_0))))
double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double t_1 = (1.0 + (hi / lo)) * t_0;
return (1.0 - (t_1 * t_1)) / (1.0 - t_0);
}
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
real(8) :: t_1
t_0 = (hi - x) / lo
t_1 = (1.0d0 + (hi / lo)) * t_0
code = (1.0d0 - (t_1 * t_1)) / (1.0d0 - t_0)
end function
public static double code(double lo, double hi, double x) {
double t_0 = (hi - x) / lo;
double t_1 = (1.0 + (hi / lo)) * t_0;
return (1.0 - (t_1 * t_1)) / (1.0 - t_0);
}
def code(lo, hi, x): t_0 = (hi - x) / lo t_1 = (1.0 + (hi / lo)) * t_0 return (1.0 - (t_1 * t_1)) / (1.0 - t_0)
function code(lo, hi, x) t_0 = Float64(Float64(hi - x) / lo) t_1 = Float64(Float64(1.0 + Float64(hi / lo)) * t_0) return Float64(Float64(1.0 - Float64(t_1 * t_1)) / Float64(1.0 - t_0)) end
function tmp = code(lo, hi, x) t_0 = (hi - x) / lo; t_1 = (1.0 + (hi / lo)) * t_0; tmp = (1.0 - (t_1 * t_1)) / (1.0 - t_0); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]}, N[(N[(1.0 - N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision] / N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{hi - x}{lo}\\
t_1 := \left(1 + \frac{hi}{lo}\right) \cdot t_0\\
\frac{1 - t_1 \cdot t_1}{1 - t_0}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.8%
distribute-lft-out--18.8%
associate-*r/18.8%
fma-neg18.8%
Simplified18.8%
flip-+18.8%
metadata-eval18.8%
Applied egg-rr18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
Simplified18.8%
Taylor expanded in lo around inf 26.5%
Final simplification26.5%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (* (+ 1.0 (/ hi lo)) (/ (- hi x) lo)))) (/ (- 1.0 (* t_0 t_0)) (- 1.0 (/ hi lo)))))
double code(double lo, double hi, double x) {
double t_0 = (1.0 + (hi / lo)) * ((hi - x) / lo);
return (1.0 - (t_0 * t_0)) / (1.0 - (hi / 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 = (1.0d0 + (hi / lo)) * ((hi - x) / lo)
code = (1.0d0 - (t_0 * t_0)) / (1.0d0 - (hi / lo))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (1.0 + (hi / lo)) * ((hi - x) / lo);
return (1.0 - (t_0 * t_0)) / (1.0 - (hi / lo));
}
def code(lo, hi, x): t_0 = (1.0 + (hi / lo)) * ((hi - x) / lo) return (1.0 - (t_0 * t_0)) / (1.0 - (hi / lo))
function code(lo, hi, x) t_0 = Float64(Float64(1.0 + Float64(hi / lo)) * Float64(Float64(hi - x) / lo)) return Float64(Float64(1.0 - Float64(t_0 * t_0)) / Float64(1.0 - Float64(hi / lo))) end
function tmp = code(lo, hi, x) t_0 = (1.0 + (hi / lo)) * ((hi - x) / lo); tmp = (1.0 - (t_0 * t_0)) / (1.0 - (hi / lo)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 - N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(1 + \frac{hi}{lo}\right) \cdot \frac{hi - x}{lo}\\
\frac{1 - t_0 \cdot t_0}{1 - \frac{hi}{lo}}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.8%
distribute-lft-out--18.8%
associate-*r/18.8%
fma-neg18.8%
Simplified18.8%
flip-+18.8%
metadata-eval18.8%
Applied egg-rr18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
Simplified18.8%
Taylor expanded in hi around 0 26.5%
+-commutative26.5%
fma-def26.5%
+-commutative26.5%
mul-1-neg26.5%
unsub-neg26.5%
unpow226.5%
mul-1-neg26.5%
Simplified26.5%
Taylor expanded in x around 0 26.5%
Final simplification26.5%
(FPCore (lo hi x) :precision binary64 (+ 1.0 (* (+ 1.0 (/ hi lo)) (/ (- hi x) lo))))
double code(double lo, double hi, double x) {
return 1.0 + ((1.0 + (hi / lo)) * ((hi - x) / 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 + ((1.0d0 + (hi / lo)) * ((hi - x) / lo))
end function
public static double code(double lo, double hi, double x) {
return 1.0 + ((1.0 + (hi / lo)) * ((hi - x) / lo));
}
def code(lo, hi, x): return 1.0 + ((1.0 + (hi / lo)) * ((hi - x) / lo))
function code(lo, hi, x) return Float64(1.0 + Float64(Float64(1.0 + Float64(hi / lo)) * Float64(Float64(hi - x) / lo))) end
function tmp = code(lo, hi, x) tmp = 1.0 + ((1.0 + (hi / lo)) * ((hi - x) / lo)); end
code[lo_, hi_, x_] := N[(1.0 + N[(N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision] * N[(N[(hi - x), $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(1 + \frac{hi}{lo}\right) \cdot \frac{hi - x}{lo}
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 0.0%
associate--l+0.0%
+-commutative0.0%
associate--l+0.0%
distribute-lft-out--0.0%
div-sub0.0%
mul-1-neg0.0%
sub-neg0.0%
unpow20.0%
times-frac18.8%
distribute-lft-out--18.8%
associate-*r/18.8%
fma-neg18.8%
Simplified18.8%
flip-+18.8%
metadata-eval18.8%
Applied egg-rr18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
fma-def18.8%
distribute-lft1-in18.8%
+-commutative18.8%
Simplified18.8%
metadata-eval18.8%
flip-+18.8%
*-commutative18.8%
+-commutative18.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 hi around inf 18.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 2023278
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))