
(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 7 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 (/ (- (pow (* (/ lo (* hi hi)) (- x lo)) 2.0) (pow (- (/ x hi) (/ lo hi)) 2.0)) (* (/ (- x lo) hi) (+ (/ lo hi) -1.0))))
double code(double lo, double hi, double x) {
return (pow(((lo / (hi * hi)) * (x - lo)), 2.0) - pow(((x / hi) - (lo / hi)), 2.0)) / (((x - 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 * hi)) * (x - lo)) ** 2.0d0) - (((x / hi) - (lo / hi)) ** 2.0d0)) / (((x - lo) / hi) * ((lo / hi) + (-1.0d0)))
end function
public static double code(double lo, double hi, double x) {
return (Math.pow(((lo / (hi * hi)) * (x - lo)), 2.0) - Math.pow(((x / hi) - (lo / hi)), 2.0)) / (((x - lo) / hi) * ((lo / hi) + -1.0));
}
def code(lo, hi, x): return (math.pow(((lo / (hi * hi)) * (x - lo)), 2.0) - math.pow(((x / hi) - (lo / hi)), 2.0)) / (((x - lo) / hi) * ((lo / hi) + -1.0))
function code(lo, hi, x) return Float64(Float64((Float64(Float64(lo / Float64(hi * hi)) * Float64(x - lo)) ^ 2.0) - (Float64(Float64(x / hi) - Float64(lo / hi)) ^ 2.0)) / Float64(Float64(Float64(x - lo) / hi) * Float64(Float64(lo / hi) + -1.0))) end
function tmp = code(lo, hi, x) tmp = ((((lo / (hi * hi)) * (x - lo)) ^ 2.0) - (((x / hi) - (lo / hi)) ^ 2.0)) / (((x - lo) / hi) * ((lo / hi) + -1.0)); end
code[lo_, hi_, x_] := N[(N[(N[Power[N[(N[(lo / N[(hi * hi), $MachinePrecision]), $MachinePrecision] * N[(x - lo), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(N[(x / hi), $MachinePrecision] - N[(lo / hi), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision] * N[(N[(lo / hi), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\left(\frac{lo}{hi \cdot hi} \cdot \left(x - lo\right)\right)}^{2} - {\left(\frac{x}{hi} - \frac{lo}{hi}\right)}^{2}}{\frac{x - lo}{hi} \cdot \left(\frac{lo}{hi} + -1\right)}
\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%
flip-+9.2%
div-sub9.2%
pow29.2%
*-commutative9.2%
clear-num9.2%
frac-times30.1%
*-un-lft-identity30.1%
associate-*r/57.7%
sub-div99.5%
Applied egg-rr6.5%
div-sub6.5%
associate-*l/6.5%
associate-/l*0.0%
*-commutative0.0%
associate-/l*6.5%
associate-/r/6.5%
div-sub72.2%
associate-*r/99.5%
*-rgt-identity99.5%
distribute-lft-out--99.2%
Simplified99.2%
div-sub99.2%
Applied egg-rr99.2%
Final simplification99.2%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- x lo) hi))) (/ (- (pow t_0 2.0)) (* t_0 (+ (/ lo hi) -1.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return -pow(t_0, 2.0) / (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 ** 2.0d0) / (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 -Math.pow(t_0, 2.0) / (t_0 * ((lo / hi) + -1.0));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return -math.pow(t_0, 2.0) / (t_0 * ((lo / hi) + -1.0))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(-(t_0 ^ 2.0)) / Float64(t_0 * Float64(Float64(lo / hi) + -1.0))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = -(t_0 ^ 2.0) / (t_0 * ((lo / hi) + -1.0)); 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[(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}^{2}}{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.2%
div-sub9.2%
Simplified9.2%
flip-+9.2%
div-sub9.2%
pow29.2%
*-commutative9.2%
clear-num9.2%
frac-times30.1%
*-un-lft-identity30.1%
associate-*r/57.7%
sub-div99.5%
Applied egg-rr6.5%
div-sub6.5%
associate-*l/6.5%
associate-/l*0.0%
*-commutative0.0%
associate-/l*6.5%
associate-/r/6.5%
div-sub72.2%
associate-*r/99.5%
*-rgt-identity99.5%
distribute-lft-out--99.2%
Simplified99.2%
div-sub99.2%
Applied egg-rr99.2%
Taylor expanded in hi around inf 0.0%
mul-1-neg0.0%
unpow20.0%
unpow20.0%
times-frac99.2%
unpow299.2%
Simplified99.2%
Final simplification99.2%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- x lo) hi))) (/ (+ (* t_0 (+ 2.0 t_0)) -1.0) (+ 1.0 (+ t_0 1.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return ((t_0 * (2.0 + t_0)) + -1.0) / (1.0 + (t_0 + 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 * (2.0d0 + t_0)) + (-1.0d0)) / (1.0d0 + (t_0 + 1.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return ((t_0 * (2.0 + t_0)) + -1.0) / (1.0 + (t_0 + 1.0));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return ((t_0 * (2.0 + t_0)) + -1.0) / (1.0 + (t_0 + 1.0))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(Float64(t_0 * Float64(2.0 + t_0)) + -1.0) / Float64(1.0 + Float64(t_0 + 1.0))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = ((t_0 * (2.0 + t_0)) + -1.0) / (1.0 + (t_0 + 1.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(1.0 + N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\frac{t_0 \cdot \left(2 + t_0\right) + -1}{1 + \left(t_0 + 1\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
expm1-log1p-u18.8%
Applied egg-rr18.8%
expm1-udef18.8%
flip--18.8%
log1p-udef18.8%
add-exp-log18.8%
log1p-udef18.8%
add-exp-log18.8%
metadata-eval18.8%
log1p-udef18.8%
add-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in hi around 0 0.0%
associate--l+0.0%
associate-*r/0.0%
associate-*r/0.0%
div-sub0.0%
+-commutative0.0%
distribute-lft-out--0.0%
associate-*r/0.0%
unpow20.0%
unpow20.0%
times-frac21.1%
distribute-rgt-in21.1%
Simplified21.1%
Final simplification21.1%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- x lo) hi))) (/ (* 2.0 t_0) (+ 1.0 (+ t_0 1.0)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return (2.0 * t_0) / (1.0 + (t_0 + 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 = (2.0d0 * t_0) / (1.0d0 + (t_0 + 1.0d0))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return (2.0 * t_0) / (1.0 + (t_0 + 1.0));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return (2.0 * t_0) / (1.0 + (t_0 + 1.0))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(2.0 * t_0) / Float64(1.0 + Float64(t_0 + 1.0))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = (2.0 * t_0) / (1.0 + (t_0 + 1.0)); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, N[(N[(2.0 * t$95$0), $MachinePrecision] / N[(1.0 + N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\frac{2 \cdot t_0}{1 + \left(t_0 + 1\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
expm1-log1p-u18.8%
Applied egg-rr18.8%
expm1-udef18.8%
flip--18.8%
log1p-udef18.8%
add-exp-log18.8%
log1p-udef18.8%
add-exp-log18.8%
metadata-eval18.8%
log1p-udef18.8%
add-exp-log18.8%
Applied egg-rr18.8%
Taylor expanded in hi around inf 3.1%
distribute-lft-out--3.1%
associate-*r/20.9%
Simplified20.9%
Final simplification20.9%
(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%
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 2023182
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))