
(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
(let* ((t_0 (/ (- x lo) hi)))
(if (<= lo -1.0902e+308)
(- 1.0 (expm1 (fabs (log (/ (- hi) lo)))))
(/
(- (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.0902e+308) {
tmp = 1.0 - expm1(fabs(log((-hi / lo))));
} else {
tmp = (pow(((x - lo) / (hi * (hi / lo))), 2.0) - pow(t_0, 2.0)) / (((lo * t_0) + (lo - x)) / hi);
}
return tmp;
}
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (lo <= -1.0902e+308) {
tmp = 1.0 - Math.expm1(Math.abs(Math.log((-hi / lo))));
} 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.0902e+308: tmp = 1.0 - math.expm1(math.fabs(math.log((-hi / lo)))) 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.0902e+308) tmp = Float64(1.0 - expm1(abs(log(Float64(Float64(-hi) / lo))))); 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
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, If[LessEqual[lo, -1.0902e+308], N[(1.0 - N[(Exp[N[Abs[N[Log[N[((-hi) / lo), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]] - 1), $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.0902 \cdot 10^{+308}:\\
\;\;\;\;1 - \mathsf{expm1}\left(\left|\log \left(\frac{-hi}{lo}\right)\right|\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.09019999999999994e308Initial program 3.1%
Taylor expanded in lo around inf 10.6%
+-commutative10.6%
associate--l+10.6%
associate-*r/10.6%
associate-*r/10.6%
div-sub10.6%
distribute-lft-out--10.6%
associate-*r/10.6%
mul-1-neg10.6%
unsub-neg10.6%
Simplified10.6%
expm1-log1p-u10.6%
Applied egg-rr10.6%
Taylor expanded in hi around inf 18.9%
+-commutative18.9%
distribute-neg-frac18.9%
metadata-eval18.9%
mul-1-neg18.9%
log-rec18.9%
remove-double-neg18.9%
Simplified18.9%
add-sqr-sqrt8.2%
sqrt-unprod20.1%
pow220.1%
sum-log20.1%
Applied egg-rr20.1%
unpow220.1%
rem-sqrt-square20.1%
associate-*l/20.1%
neg-mul-120.1%
Simplified20.1%
if -1.09019999999999994e308 < 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.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times67.3%
*-un-lft-identity67.3%
pow267.3%
associate-*r/67.3%
sub-div46.3%
Applied egg-rr46.3%
Final simplification23.3%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)))
(if (<= lo -1.0902e+308)
(- 1.0 (fabs (+ (/ hi lo) 1.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.0902e+308) {
tmp = 1.0 - fabs(((hi / lo) + 1.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.0902d+308)) then
tmp = 1.0d0 - abs(((hi / lo) + 1.0d0))
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.0902e+308) {
tmp = 1.0 - Math.abs(((hi / lo) + 1.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.0902e+308: tmp = 1.0 - math.fabs(((hi / lo) + 1.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.0902e+308) tmp = Float64(1.0 - abs(Float64(Float64(hi / lo) + 1.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.0902e+308) tmp = 1.0 - abs(((hi / lo) + 1.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.0902e+308], N[(1.0 - N[Abs[N[(N[(hi / lo), $MachinePrecision] + 1.0), $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.0902 \cdot 10^{+308}:\\
\;\;\;\;1 - \left|\frac{hi}{lo} + 1\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.09019999999999994e308Initial program 3.1%
Taylor expanded in lo around inf 10.6%
+-commutative10.6%
associate--l+10.6%
associate-*r/10.6%
associate-*r/10.6%
div-sub10.6%
distribute-lft-out--10.6%
associate-*r/10.6%
mul-1-neg10.6%
unsub-neg10.6%
Simplified10.6%
expm1-log1p-u10.6%
Applied egg-rr10.6%
Taylor expanded in hi around inf 18.9%
+-commutative18.9%
distribute-neg-frac18.9%
metadata-eval18.9%
mul-1-neg18.9%
log-rec18.9%
remove-double-neg18.9%
Simplified18.9%
add-sqr-sqrt8.2%
sqrt-unprod20.0%
pow220.0%
expm1-udef20.0%
sum-log20.0%
add-exp-log20.0%
Applied egg-rr20.0%
unpow220.0%
sqr-neg20.0%
rem-sqrt-square20.0%
sub-neg20.0%
metadata-eval20.0%
distribute-neg-in20.0%
associate-*l/20.0%
neg-mul-120.0%
distribute-neg-frac20.0%
remove-double-neg20.0%
metadata-eval20.0%
Simplified20.0%
if -1.09019999999999994e308 < 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.3%
div-sub18.3%
Simplified18.3%
flip-+18.3%
pow218.3%
*-commutative18.3%
clear-num18.3%
frac-times67.3%
*-un-lft-identity67.3%
pow267.3%
associate-*r/67.3%
sub-div46.3%
Applied egg-rr46.3%
Final simplification23.2%
(FPCore (lo hi x) :precision binary64 (- 1.0 (fabs (+ 1.0 (/ hi lo)))))
double code(double lo, double hi, double x) {
return 1.0 - fabs((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
code = 1.0d0 - abs((1.0d0 + (hi / lo)))
end function
public static double code(double lo, double hi, double x) {
return 1.0 - Math.abs((1.0 + (hi / lo)));
}
def code(lo, hi, x): return 1.0 - math.fabs((1.0 + (hi / lo)))
function code(lo, hi, x) return Float64(1.0 - abs(Float64(1.0 + Float64(hi / lo)))) end
function tmp = code(lo, hi, x) tmp = 1.0 - abs((1.0 + (hi / lo))); end
code[lo_, hi_, x_] := N[(1.0 - N[Abs[N[(1.0 + N[(hi / lo), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \left|1 + \frac{hi}{lo}\right|
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 9.5%
+-commutative9.5%
associate--l+9.5%
associate-*r/9.5%
associate-*r/9.5%
div-sub9.5%
distribute-lft-out--9.5%
associate-*r/9.5%
mul-1-neg9.5%
unsub-neg9.5%
Simplified9.5%
expm1-log1p-u9.5%
Applied egg-rr9.5%
Taylor expanded in hi around inf 19.1%
+-commutative19.1%
distribute-neg-frac19.1%
metadata-eval19.1%
mul-1-neg19.1%
log-rec19.1%
remove-double-neg19.1%
Simplified19.1%
add-sqr-sqrt9.7%
sqrt-unprod20.0%
pow220.0%
expm1-udef20.0%
sum-log20.0%
add-exp-log20.0%
Applied egg-rr20.0%
unpow220.0%
sqr-neg20.0%
rem-sqrt-square20.0%
sub-neg20.0%
metadata-eval20.0%
distribute-neg-in20.0%
associate-*l/20.0%
neg-mul-120.0%
distribute-neg-frac20.0%
remove-double-neg20.0%
metadata-eval20.0%
Simplified20.0%
Final simplification20.0%
(FPCore (lo hi x) :precision binary64 (+ (/ hi lo) 2.0))
double code(double lo, double hi, double x) {
return (hi / lo) + 2.0;
}
real(8) function code(lo, hi, x)
real(8), intent (in) :: lo
real(8), intent (in) :: hi
real(8), intent (in) :: x
code = (hi / lo) + 2.0d0
end function
public static double code(double lo, double hi, double x) {
return (hi / lo) + 2.0;
}
def code(lo, hi, x): return (hi / lo) + 2.0
function code(lo, hi, x) return Float64(Float64(hi / lo) + 2.0) end
function tmp = code(lo, hi, x) tmp = (hi / lo) + 2.0; end
code[lo_, hi_, x_] := N[(N[(hi / lo), $MachinePrecision] + 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{hi}{lo} + 2
\end{array}
Initial program 3.1%
Taylor expanded in lo around inf 9.5%
+-commutative9.5%
associate--l+9.5%
associate-*r/9.5%
associate-*r/9.5%
div-sub9.5%
distribute-lft-out--9.5%
associate-*r/9.5%
mul-1-neg9.5%
unsub-neg9.5%
Simplified9.5%
expm1-log1p-u9.5%
Applied egg-rr9.5%
Taylor expanded in hi around inf 19.1%
+-commutative19.1%
distribute-neg-frac19.1%
metadata-eval19.1%
mul-1-neg19.1%
log-rec19.1%
remove-double-neg19.1%
Simplified19.1%
Taylor expanded in lo around 0 0.0%
exp-sum0.0%
mul-1-neg0.0%
log-rec0.0%
exp-sum0.0%
log-rec0.0%
mul-1-neg0.0%
+-commutative0.0%
+-commutative0.0%
associate-+l+0.0%
mul-1-neg0.0%
sub-neg0.0%
log-div19.1%
+-commutative19.1%
log-prod19.1%
rem-exp-log19.1%
Simplified19.1%
Final simplification19.1%
(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 2023252
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))