
(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)))
(if (<= lo -1.05275e+308)
(* (+ (+ 1.0 (* 2.0 t_0)) -1.0) (/ 1.0 (+ 1.0 (+ 1.0 t_0))))
(*
(- (pow (* (- x lo) (/ lo (* hi hi))) 2.0) (pow t_0 2.0))
(/ 1.0 (/ (+ (* lo t_0) (- lo x)) hi))))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.05275e+308) {
tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)));
} else {
tmp = (pow(((x - lo) * (lo / (hi * hi))), 2.0) - pow(t_0, 2.0)) * (1.0 / (((lo * t_0) + (lo - x)) / hi));
}
return tmp;
}
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) :: tmp
t_0 = (x - lo) / hi
if (lo <= (-1.05275d+308)) then
tmp = ((1.0d0 + (2.0d0 * t_0)) + (-1.0d0)) * (1.0d0 / (1.0d0 + (1.0d0 + t_0)))
else
tmp = ((((x - lo) * (lo / (hi * hi))) ** 2.0d0) - (t_0 ** 2.0d0)) * (1.0d0 / (((lo * t_0) + (lo - x)) / hi))
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.05275e+308) {
tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)));
} else {
tmp = (Math.pow(((x - lo) * (lo / (hi * hi))), 2.0) - Math.pow(t_0, 2.0)) * (1.0 / (((lo * t_0) + (lo - x)) / hi));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi tmp = 0 if lo <= -1.05275e+308: tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0))) else: tmp = (math.pow(((x - lo) * (lo / (hi * hi))), 2.0) - math.pow(t_0, 2.0)) * (1.0 / (((lo * t_0) + (lo - x)) / hi)) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) tmp = 0.0 if (lo <= -1.05275e+308) tmp = Float64(Float64(Float64(1.0 + Float64(2.0 * t_0)) + -1.0) * Float64(1.0 / Float64(1.0 + Float64(1.0 + t_0)))); else tmp = Float64(Float64((Float64(Float64(x - lo) * Float64(lo / Float64(hi * hi))) ^ 2.0) - (t_0 ^ 2.0)) * Float64(1.0 / Float64(Float64(Float64(lo * t_0) + Float64(lo - x)) / hi))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = 0.0; if (lo <= -1.05275e+308) tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0))); else tmp = ((((x - lo) * (lo / (hi * hi))) ^ 2.0) - (t_0 ^ 2.0)) * (1.0 / (((lo * t_0) + (lo - x)) / hi)); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, If[LessEqual[lo, -1.05275e+308], N[(N[(N[(1.0 + N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] * N[(1.0 / N[(1.0 + N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] * N[(lo / N[(hi * hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(lo * t$95$0), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\mathbf{if}\;lo \leq -1.05275 \cdot 10^{+308}:\\
\;\;\;\;\left(\left(1 + 2 \cdot t_0\right) + -1\right) \cdot \frac{1}{1 + \left(1 + t_0\right)}\\
\mathbf{else}:\\
\;\;\;\;\left({\left(\left(x - lo\right) \cdot \frac{lo}{hi \cdot hi}\right)}^{2} - {t_0}^{2}\right) \cdot \frac{1}{\frac{lo \cdot t_0 + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.05274999999999995e308Initial program 3.1%
Taylor expanded in hi around inf 18.8%
expm1-log1p-u18.8%
expm1-udef18.8%
Applied egg-rr18.8%
flip--18.8%
div-inv18.8%
metadata-eval18.8%
sub-neg18.8%
pow218.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 20.9%
associate--l+20.9%
associate-*r/20.9%
associate-*r/3.1%
div-sub3.1%
distribute-lft-out--3.1%
associate-*r/20.9%
Simplified20.9%
if -1.05274999999999995e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.2%
div-sub18.2%
Simplified18.2%
div-inv18.2%
inv-pow18.2%
Applied egg-rr18.2%
unpow-118.2%
Simplified18.2%
flip-+18.2%
div-inv18.2%
pow218.2%
associate-*l*18.2%
frac-times98.6%
*-un-lft-identity98.6%
pow298.6%
Applied egg-rr51.2%
Final simplification22.6%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)))
(if (<= lo -1.05275e+308)
(* (+ (+ 1.0 (* 2.0 t_0)) -1.0) (/ 1.0 (+ 1.0 (+ 1.0 t_0))))
(/
(- (pow (/ (- x lo) (* hi (/ hi lo))) 2.0) (pow t_0 2.0))
(/ (+ (* lo t_0) (- lo x)) hi)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.05275e+308) {
tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)));
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) - pow(t_0, 2.0)) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
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) :: tmp
t_0 = (x - lo) / hi
if (lo <= (-1.05275d+308)) then
tmp = ((1.0d0 + (2.0d0 * t_0)) + (-1.0d0)) * (1.0d0 / (1.0d0 + (1.0d0 + t_0)))
else
tmp = ((((x - lo) / (hi * (hi / lo))) ** 2.0d0) - (t_0 ** 2.0d0)) / (((lo * t_0) + (lo - x)) / hi)
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.05275e+308) {
tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)));
} else {
tmp = (Math.pow(((x - lo) / (hi * (hi / lo))), 2.0) - Math.pow(t_0, 2.0)) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi tmp = 0 if lo <= -1.05275e+308: tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0))) else: tmp = (math.pow(((x - lo) / (hi * (hi / lo))), 2.0) - math.pow(t_0, 2.0)) / (((lo * t_0) + (lo - x)) / hi) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) tmp = 0.0 if (lo <= -1.05275e+308) tmp = Float64(Float64(Float64(1.0 + Float64(2.0 * t_0)) + -1.0) * Float64(1.0 / Float64(1.0 + Float64(1.0 + t_0)))); else tmp = Float64(Float64((Float64(Float64(x - lo) / Float64(hi * Float64(hi / lo))) ^ 2.0) - (t_0 ^ 2.0)) / Float64(Float64(Float64(lo * t_0) + Float64(lo - x)) / hi)); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = 0.0; if (lo <= -1.05275e+308) tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0))); else tmp = ((((x - lo) / (hi * (hi / lo))) ^ 2.0) - (t_0 ^ 2.0)) / (((lo * t_0) + (lo - x)) / hi); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, If[LessEqual[lo, -1.05275e+308], N[(N[(N[(1.0 + N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] * N[(1.0 / N[(1.0 + N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[N[(N[(x - lo), $MachinePrecision] / N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(lo * t$95$0), $MachinePrecision] + N[(lo - x), $MachinePrecision]), $MachinePrecision] / hi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\mathbf{if}\;lo \leq -1.05275 \cdot 10^{+308}:\\
\;\;\;\;\left(\left(1 + 2 \cdot t_0\right) + -1\right) \cdot \frac{1}{1 + \left(1 + t_0\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{x - lo}{hi \cdot \frac{hi}{lo}}\right)}^{2} - {t_0}^{2}}{\frac{lo \cdot t_0 + \left(lo - x\right)}{hi}}\\
\end{array}
\end{array}
if lo < -1.05274999999999995e308Initial program 3.1%
Taylor expanded in hi around inf 18.8%
expm1-log1p-u18.8%
expm1-udef18.8%
Applied egg-rr18.8%
flip--18.8%
div-inv18.8%
metadata-eval18.8%
sub-neg18.8%
pow218.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 20.9%
associate--l+20.9%
associate-*r/20.9%
associate-*r/3.1%
div-sub3.1%
distribute-lft-out--3.1%
associate-*r/20.9%
Simplified20.9%
if -1.05274999999999995e308 < lo Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac18.2%
div-sub18.2%
Simplified18.2%
flip-+18.2%
pow218.2%
*-commutative18.2%
clear-num18.2%
frac-times58.0%
*-un-lft-identity58.0%
pow258.0%
associate-*r/58.0%
sub-div51.0%
Applied egg-rr51.0%
Final simplification22.6%
(FPCore (lo hi x) :precision binary64 (let* ((t_0 (/ (- x lo) hi))) (* (+ (+ 1.0 (* 2.0 t_0)) -1.0) (/ 1.0 (+ 1.0 (+ 1.0 t_0))))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (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
t_0 = (x - lo) / hi
code = ((1.0d0 + (2.0d0 * t_0)) + (-1.0d0)) * (1.0d0 / (1.0d0 + (1.0d0 + t_0)))
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
return ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)));
}
def code(lo, hi, x): t_0 = (x - lo) / hi return ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0)))
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) return Float64(Float64(Float64(1.0 + Float64(2.0 * t_0)) + -1.0) * Float64(1.0 / Float64(1.0 + Float64(1.0 + t_0)))) end
function tmp = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = ((1.0 + (2.0 * t_0)) + -1.0) * (1.0 / (1.0 + (1.0 + t_0))); end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, N[(N[(N[(1.0 + N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] * N[(1.0 / N[(1.0 + N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\left(\left(1 + 2 \cdot t_0\right) + -1\right) \cdot \frac{1}{1 + \left(1 + t_0\right)}
\end{array}
\end{array}
Initial program 3.1%
Taylor expanded in hi around inf 18.8%
expm1-log1p-u18.8%
expm1-udef18.8%
Applied egg-rr18.8%
flip--18.8%
div-inv18.8%
metadata-eval18.8%
sub-neg18.8%
pow218.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 20.9%
associate--l+20.9%
associate-*r/20.9%
associate-*r/3.1%
div-sub3.1%
distribute-lft-out--3.1%
associate-*r/20.9%
Simplified20.9%
Final simplification20.9%
(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 2023250
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))