
(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 (/ (- x lo) hi))) (/ (- (pow t_0 2.0)) (+ (* t_0 (/ lo hi)) (/ (- lo x) hi)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return -pow(t_0, 2.0) / ((t_0 * (lo / hi)) + ((lo - x) / hi));
}
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 = (x - lo) / hi
code = -(t_0 ** 2.0d0) / ((t_0 * (lo / hi)) + ((lo - x) / hi))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return -Math.pow(t_0, 2.0) / ((t_0 * (lo / hi)) + ((lo - x) / hi));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return -math.pow(t_0, 2.0) / ((t_0 * (lo / hi)) + ((lo - x) / hi))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(-(t_0 ^ 2.0)) / Float64(Float64(t_0 * Float64(lo / hi)) + Float64(Float64(lo - x) / hi))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = -(t_0 ^ 2.0) / ((t_0 * (lo / hi)) + ((lo - x) / hi)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, N[((-N[Power[t$95$0, 2.0], $MachinePrecision]) / N[(N[(t$95$0 * N[(lo / hi), $MachinePrecision]), $MachinePrecision] + N[(N[(lo - x), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\frac{-{t_0}^{2}}{t_0 \cdot \frac{lo}{hi} + \frac{lo - x}{hi}}
\end{array}
\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.6%
div-sub9.6%
Simplified9.6%
flip-+9.6%
div-sub9.6%
Applied egg-rr0.0%
div-sub0.0%
associate-*l*99.2%
sub-neg99.2%
metadata-eval99.2%
Simplified99.2%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.2%
unpow299.2%
Simplified99.2%
distribute-lft-in99.5%
Applied egg-rr99.5%
Final simplification99.5%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- x lo) hi))) (/ (* t_0 (/ (- lo x) hi)) (* t_0 (+ (/ lo hi) -1.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return (t_0 * ((lo - x) / hi)) / (t_0 * ((lo / 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
real(8) :: t_0
t_0 = (x - lo) / hi
code = (t_0 * ((lo - x) / hi)) / (t_0 * ((lo / hi) + (-1.0d0)))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return (t_0 * ((lo - x) / hi)) / (t_0 * ((lo / hi) + -1.0));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return (t_0 * ((lo - x) / hi)) / (t_0 * ((lo / hi) + -1.0))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(t_0 * Float64(Float64(lo - x) / hi)) / Float64(t_0 * Float64(Float64(lo / hi) + -1.0))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = (t_0 * ((lo - x) / hi)) / (t_0 * ((lo / hi) + -1.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, N[(N[(t$95$0 * N[(N[(lo - x), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * N[(N[(lo / hi), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\frac{t_0 \cdot \frac{lo - x}{hi}}{t_0 \cdot \left(\frac{lo}{hi} + -1\right)}
\end{array}
\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.6%
div-sub9.6%
Simplified9.6%
flip-+9.6%
div-sub9.6%
Applied egg-rr0.0%
div-sub0.0%
associate-*l*99.2%
sub-neg99.2%
metadata-eval99.2%
Simplified99.2%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.2%
unpow299.2%
Simplified99.2%
unpow299.2%
Applied egg-rr99.2%
Final simplification99.2%
(FPCore (lo hi x) :precision binary64 (/ (/ lo hi) (+ (/ lo hi) -1.0)))
double code(double lo, double hi, double x) {
return (lo / hi) / ((lo / 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 = (lo / hi) / ((lo / hi) + (-1.0d0))
end function
public static double code(double lo, double hi, double x) {
return (lo / hi) / ((lo / hi) + -1.0);
}
def code(lo, hi, x): return (lo / hi) / ((lo / hi) + -1.0)
function code(lo, hi, x) return Float64(Float64(lo / hi) / Float64(Float64(lo / hi) + -1.0)) end
function tmp = code(lo, hi, x) tmp = (lo / hi) / ((lo / hi) + -1.0); end
code[lo_, hi_, x_] := N[(N[(lo / hi), $MachinePrecision] / N[(N[(lo / hi), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{lo}{hi}}{\frac{lo}{hi} + -1}
\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.6%
div-sub9.6%
Simplified9.6%
flip-+9.6%
div-sub9.6%
Applied egg-rr0.0%
div-sub0.0%
associate-*l*99.2%
sub-neg99.2%
metadata-eval99.2%
Simplified99.2%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.2%
unpow299.2%
Simplified99.2%
Taylor expanded in x around 0 3.1%
sub-neg3.1%
metadata-eval3.1%
associate-/r*98.4%
Simplified98.4%
Final simplification98.4%
(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 2023199
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))