
(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 9 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))
(t_1 (* t_0 (- 1.0 (/ lo hi))))
(t_2 (/ (* hi (/ hi lo)) (- x lo)))
(t_3 (pow t_2 -2.0))
(t_4 (pow t_0 2.0)))
(if (<= x -1.8e-16)
(/ (+ (pow t_0 3.0) (pow t_2 -3.0)) (fma t_0 t_1 t_3))
(if (<= x 1.45)
(/ (- t_4 (pow (/ (* hi hi) (* x lo)) -2.0)) t_1)
(/ (- (+ (exp (log1p t_4)) -1.0) t_3) t_1)))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = t_0 * (1.0 - (lo / hi));
double t_2 = (hi * (hi / lo)) / (x - lo);
double t_3 = pow(t_2, -2.0);
double t_4 = pow(t_0, 2.0);
double tmp;
if (x <= -1.8e-16) {
tmp = (pow(t_0, 3.0) + pow(t_2, -3.0)) / fma(t_0, t_1, t_3);
} else if (x <= 1.45) {
tmp = (t_4 - pow(((hi * hi) / (x * lo)), -2.0)) / t_1;
} else {
tmp = ((exp(log1p(t_4)) + -1.0) - t_3) / t_1;
}
return tmp;
}
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) t_1 = Float64(t_0 * Float64(1.0 - Float64(lo / hi))) t_2 = Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) t_3 = t_2 ^ -2.0 t_4 = t_0 ^ 2.0 tmp = 0.0 if (x <= -1.8e-16) tmp = Float64(Float64((t_0 ^ 3.0) + (t_2 ^ -3.0)) / fma(t_0, t_1, t_3)); elseif (x <= 1.45) tmp = Float64(Float64(t_4 - (Float64(Float64(hi * hi) / Float64(x * lo)) ^ -2.0)) / t_1); else tmp = Float64(Float64(Float64(exp(log1p(t_4)) + -1.0) - t_3) / t_1); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[t$95$2, -2.0], $MachinePrecision]}, Block[{t$95$4 = N[Power[t$95$0, 2.0], $MachinePrecision]}, If[LessEqual[x, -1.8e-16], N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$2, -3.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$1 + t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.45], N[(N[(t$95$4 - N[Power[N[(N[(hi * hi), $MachinePrecision] / N[(x * lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[(N[(N[Exp[N[Log[1 + t$95$4], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision] - t$95$3), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
t_1 := t_0 \cdot \left(1 - \frac{lo}{hi}\right)\\
t_2 := \frac{hi \cdot \frac{hi}{lo}}{x - lo}\\
t_3 := {t_2}^{-2}\\
t_4 := {t_0}^{2}\\
\mathbf{if}\;x \leq -1.8 \cdot 10^{-16}:\\
\;\;\;\;\frac{{t_0}^{3} + {t_2}^{-3}}{\mathsf{fma}\left(t_0, t_1, t_3\right)}\\
\mathbf{elif}\;x \leq 1.45:\\
\;\;\;\;\frac{t_4 - {\left(\frac{hi \cdot hi}{x \cdot lo}\right)}^{-2}}{t_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(e^{\mathsf{log1p}\left(t_4\right)} + -1\right) - t_3}{t_1}\\
\end{array}
\end{array}
if x < -1.79999999999999991e-16Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac9.1%
div-sub9.1%
Simplified9.1%
clear-num9.1%
clear-num9.1%
frac-times9.1%
metadata-eval9.1%
Applied egg-rr9.1%
flip3-+9.1%
div-inv9.1%
Applied egg-rr9.1%
associate-*r/9.1%
*-rgt-identity9.1%
+-commutative9.1%
associate-*r/9.9%
+-commutative9.9%
fma-def9.9%
*-rgt-identity9.9%
distribute-lft-out--9.9%
Simplified34.1%
if -1.79999999999999991e-16 < x < 1.44999999999999996Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac9.1%
div-sub9.1%
Simplified9.1%
clear-num9.1%
clear-num9.1%
frac-times9.1%
metadata-eval9.1%
Applied egg-rr9.1%
+-commutative9.1%
flip-+9.1%
pow29.1%
inv-pow9.1%
inv-pow9.1%
pow-prod-up9.1%
associate-*l/29.4%
*-un-lft-identity29.4%
times-frac9.1%
/-rgt-identity9.1%
metadata-eval9.1%
Applied egg-rr9.1%
associate-*r/29.6%
*-rgt-identity29.6%
distribute-lft-out--29.6%
Simplified29.6%
Taylor expanded in lo around 0 99.2%
unpow299.2%
Simplified99.2%
if 1.44999999999999996 < x Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.8%
div-sub8.8%
Simplified8.8%
clear-num8.8%
clear-num8.8%
frac-times8.8%
metadata-eval8.8%
Applied egg-rr8.8%
+-commutative8.8%
flip-+8.8%
pow28.8%
inv-pow8.8%
inv-pow8.8%
pow-prod-up8.8%
associate-*l/27.6%
*-un-lft-identity27.6%
times-frac8.8%
/-rgt-identity8.8%
metadata-eval8.8%
Applied egg-rr8.8%
associate-*r/27.7%
*-rgt-identity27.7%
distribute-lft-out--27.6%
Simplified27.6%
expm1-log1p-u27.6%
expm1-udef27.6%
Applied egg-rr27.6%
Final simplification63.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (pow (/ (* hi (/ hi lo)) (- x lo)) -2.0))
(t_1 (/ (- x lo) hi))
(t_2 (* t_1 (- 1.0 (/ lo hi))))
(t_3 (pow t_1 2.0)))
(if (<= x -1.4)
(/ (- (log (+ 1.0 (expm1 t_3))) t_0) t_2)
(if (<= x 1.35)
(/ (- t_3 (pow (/ (* hi hi) (* x lo)) -2.0)) t_2)
(/ (- (+ (exp (log1p t_3)) -1.0) t_0) t_2)))))
double code(double lo, double hi, double x) {
double t_0 = pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (log((1.0 + expm1(t_3))) - t_0) / t_2;
} else if (x <= 1.35) {
tmp = (t_3 - pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((exp(log1p(t_3)) + -1.0) - t_0) / t_2;
}
return tmp;
}
public static double code(double lo, double hi, double x) {
double t_0 = Math.pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = Math.pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (Math.log((1.0 + Math.expm1(t_3))) - t_0) / t_2;
} else if (x <= 1.35) {
tmp = (t_3 - Math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((Math.exp(Math.log1p(t_3)) + -1.0) - t_0) / t_2;
}
return tmp;
}
def code(lo, hi, x): t_0 = math.pow(((hi * (hi / lo)) / (x - lo)), -2.0) t_1 = (x - lo) / hi t_2 = t_1 * (1.0 - (lo / hi)) t_3 = math.pow(t_1, 2.0) tmp = 0 if x <= -1.4: tmp = (math.log((1.0 + math.expm1(t_3))) - t_0) / t_2 elif x <= 1.35: tmp = (t_3 - math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2 else: tmp = ((math.exp(math.log1p(t_3)) + -1.0) - t_0) / t_2 return tmp
function code(lo, hi, x) t_0 = Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) ^ -2.0 t_1 = Float64(Float64(x - lo) / hi) t_2 = Float64(t_1 * Float64(1.0 - Float64(lo / hi))) t_3 = t_1 ^ 2.0 tmp = 0.0 if (x <= -1.4) tmp = Float64(Float64(log(Float64(1.0 + expm1(t_3))) - t_0) / t_2); elseif (x <= 1.35) tmp = Float64(Float64(t_3 - (Float64(Float64(hi * hi) / Float64(x * lo)) ^ -2.0)) / t_2); else tmp = Float64(Float64(Float64(exp(log1p(t_3)) + -1.0) - t_0) / t_2); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$1 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[t$95$1, 2.0], $MachinePrecision]}, If[LessEqual[x, -1.4], N[(N[(N[Log[N[(1.0 + N[(Exp[t$95$3] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[x, 1.35], N[(N[(t$95$3 - N[Power[N[(N[(hi * hi), $MachinePrecision] / N[(x * lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(N[Exp[N[Log[1 + t$95$3], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{hi \cdot \frac{hi}{lo}}{x - lo}\right)}^{-2}\\
t_1 := \frac{x - lo}{hi}\\
t_2 := t_1 \cdot \left(1 - \frac{lo}{hi}\right)\\
t_3 := {t_1}^{2}\\
\mathbf{if}\;x \leq -1.4:\\
\;\;\;\;\frac{\log \left(1 + \mathsf{expm1}\left(t_3\right)\right) - t_0}{t_2}\\
\mathbf{elif}\;x \leq 1.35:\\
\;\;\;\;\frac{t_3 - {\left(\frac{hi \cdot hi}{x \cdot lo}\right)}^{-2}}{t_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(e^{\mathsf{log1p}\left(t_3\right)} + -1\right) - t_0}{t_2}\\
\end{array}
\end{array}
if x < -1.3999999999999999Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
clear-num8.9%
clear-num8.9%
frac-times8.9%
metadata-eval8.9%
Applied egg-rr8.9%
+-commutative8.9%
flip-+8.9%
pow28.9%
inv-pow8.9%
inv-pow8.9%
pow-prod-up8.9%
associate-*l/32.9%
*-un-lft-identity32.9%
times-frac8.9%
/-rgt-identity8.9%
metadata-eval8.9%
Applied egg-rr8.9%
associate-*r/32.9%
*-rgt-identity32.9%
distribute-lft-out--32.9%
Simplified32.9%
log1p-expm1-u32.9%
log1p-udef32.9%
Applied egg-rr32.9%
if -1.3999999999999999 < x < 1.3500000000000001Initial 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%
clear-num9.2%
clear-num9.2%
frac-times9.2%
metadata-eval9.2%
Applied egg-rr9.2%
+-commutative9.2%
flip-+9.2%
pow29.2%
inv-pow9.2%
inv-pow9.2%
pow-prod-up9.2%
associate-*l/29.9%
*-un-lft-identity29.9%
times-frac9.2%
/-rgt-identity9.2%
metadata-eval9.2%
Applied egg-rr9.2%
associate-*r/30.1%
*-rgt-identity30.1%
distribute-lft-out--30.1%
Simplified30.1%
Taylor expanded in lo around 0 99.2%
unpow299.2%
Simplified99.2%
if 1.3500000000000001 < x Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.8%
div-sub8.8%
Simplified8.8%
clear-num8.8%
clear-num8.8%
frac-times8.8%
metadata-eval8.8%
Applied egg-rr8.8%
+-commutative8.8%
flip-+8.8%
pow28.8%
inv-pow8.8%
inv-pow8.8%
pow-prod-up8.8%
associate-*l/27.6%
*-un-lft-identity27.6%
times-frac8.8%
/-rgt-identity8.8%
metadata-eval8.8%
Applied egg-rr8.8%
associate-*r/27.7%
*-rgt-identity27.7%
distribute-lft-out--27.6%
Simplified27.6%
expm1-log1p-u27.6%
expm1-udef27.6%
Applied egg-rr27.6%
Final simplification63.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (pow (/ (* hi (/ hi lo)) (- x lo)) -2.0))
(t_1 (/ (- x lo) hi))
(t_2 (* t_1 (- 1.0 (/ lo hi))))
(t_3 (pow t_1 2.0)))
(if (<= x -1.4)
(/ (- (log (+ 1.0 (expm1 t_3))) t_0) t_2)
(if (<= x 1.35)
(/ (- t_3 (pow (/ (* hi hi) (* x lo)) -2.0)) t_2)
(/ (- (* t_1 t_1) t_0) t_2)))))
double code(double lo, double hi, double x) {
double t_0 = pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (log((1.0 + expm1(t_3))) - t_0) / t_2;
} else if (x <= 1.35) {
tmp = (t_3 - pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((t_1 * t_1) - t_0) / t_2;
}
return tmp;
}
public static double code(double lo, double hi, double x) {
double t_0 = Math.pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = Math.pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (Math.log((1.0 + Math.expm1(t_3))) - t_0) / t_2;
} else if (x <= 1.35) {
tmp = (t_3 - Math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((t_1 * t_1) - t_0) / t_2;
}
return tmp;
}
def code(lo, hi, x): t_0 = math.pow(((hi * (hi / lo)) / (x - lo)), -2.0) t_1 = (x - lo) / hi t_2 = t_1 * (1.0 - (lo / hi)) t_3 = math.pow(t_1, 2.0) tmp = 0 if x <= -1.4: tmp = (math.log((1.0 + math.expm1(t_3))) - t_0) / t_2 elif x <= 1.35: tmp = (t_3 - math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2 else: tmp = ((t_1 * t_1) - t_0) / t_2 return tmp
function code(lo, hi, x) t_0 = Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) ^ -2.0 t_1 = Float64(Float64(x - lo) / hi) t_2 = Float64(t_1 * Float64(1.0 - Float64(lo / hi))) t_3 = t_1 ^ 2.0 tmp = 0.0 if (x <= -1.4) tmp = Float64(Float64(log(Float64(1.0 + expm1(t_3))) - t_0) / t_2); elseif (x <= 1.35) tmp = Float64(Float64(t_3 - (Float64(Float64(hi * hi) / Float64(x * lo)) ^ -2.0)) / t_2); else tmp = Float64(Float64(Float64(t_1 * t_1) - t_0) / t_2); end return tmp end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$1 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[t$95$1, 2.0], $MachinePrecision]}, If[LessEqual[x, -1.4], N[(N[(N[Log[N[(1.0 + N[(Exp[t$95$3] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[x, 1.35], N[(N[(t$95$3 - N[Power[N[(N[(hi * hi), $MachinePrecision] / N[(x * lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(t$95$1 * t$95$1), $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{hi \cdot \frac{hi}{lo}}{x - lo}\right)}^{-2}\\
t_1 := \frac{x - lo}{hi}\\
t_2 := t_1 \cdot \left(1 - \frac{lo}{hi}\right)\\
t_3 := {t_1}^{2}\\
\mathbf{if}\;x \leq -1.4:\\
\;\;\;\;\frac{\log \left(1 + \mathsf{expm1}\left(t_3\right)\right) - t_0}{t_2}\\
\mathbf{elif}\;x \leq 1.35:\\
\;\;\;\;\frac{t_3 - {\left(\frac{hi \cdot hi}{x \cdot lo}\right)}^{-2}}{t_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t_1 \cdot t_1 - t_0}{t_2}\\
\end{array}
\end{array}
if x < -1.3999999999999999Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
clear-num8.9%
clear-num8.9%
frac-times8.9%
metadata-eval8.9%
Applied egg-rr8.9%
+-commutative8.9%
flip-+8.9%
pow28.9%
inv-pow8.9%
inv-pow8.9%
pow-prod-up8.9%
associate-*l/32.9%
*-un-lft-identity32.9%
times-frac8.9%
/-rgt-identity8.9%
metadata-eval8.9%
Applied egg-rr8.9%
associate-*r/32.9%
*-rgt-identity32.9%
distribute-lft-out--32.9%
Simplified32.9%
log1p-expm1-u32.9%
log1p-udef32.9%
Applied egg-rr32.9%
if -1.3999999999999999 < x < 1.3500000000000001Initial 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%
clear-num9.2%
clear-num9.2%
frac-times9.2%
metadata-eval9.2%
Applied egg-rr9.2%
+-commutative9.2%
flip-+9.2%
pow29.2%
inv-pow9.2%
inv-pow9.2%
pow-prod-up9.2%
associate-*l/29.9%
*-un-lft-identity29.9%
times-frac9.2%
/-rgt-identity9.2%
metadata-eval9.2%
Applied egg-rr9.2%
associate-*r/30.1%
*-rgt-identity30.1%
distribute-lft-out--30.1%
Simplified30.1%
Taylor expanded in lo around 0 99.2%
unpow299.2%
Simplified99.2%
if 1.3500000000000001 < x Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.8%
div-sub8.8%
Simplified8.8%
clear-num8.8%
clear-num8.8%
frac-times8.8%
metadata-eval8.8%
Applied egg-rr8.8%
+-commutative8.8%
flip-+8.8%
pow28.8%
inv-pow8.8%
inv-pow8.8%
pow-prod-up8.8%
associate-*l/27.6%
*-un-lft-identity27.6%
times-frac8.8%
/-rgt-identity8.8%
metadata-eval8.8%
Applied egg-rr8.8%
associate-*r/27.7%
*-rgt-identity27.7%
distribute-lft-out--27.6%
Simplified27.6%
unpow227.6%
Applied egg-rr27.6%
Final simplification63.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (pow (/ (* hi (/ hi lo)) (- x lo)) -2.0))
(t_1 (/ (- x lo) hi))
(t_2 (* t_1 (- 1.0 (/ lo hi))))
(t_3 (pow t_1 2.0)))
(if (<= x -1.4)
(/ (- (log (exp t_3)) t_0) t_2)
(if (<= x 1.25)
(/ (- t_3 (pow (/ (* hi hi) (* x lo)) -2.0)) t_2)
(/ (- (* t_1 t_1) t_0) t_2)))))
double code(double lo, double hi, double x) {
double t_0 = pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (log(exp(t_3)) - t_0) / t_2;
} else if (x <= 1.25) {
tmp = (t_3 - pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((t_1 * t_1) - t_0) / t_2;
}
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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = ((hi * (hi / lo)) / (x - lo)) ** (-2.0d0)
t_1 = (x - lo) / hi
t_2 = t_1 * (1.0d0 - (lo / hi))
t_3 = t_1 ** 2.0d0
if (x <= (-1.4d0)) then
tmp = (log(exp(t_3)) - t_0) / t_2
else if (x <= 1.25d0) then
tmp = (t_3 - (((hi * hi) / (x * lo)) ** (-2.0d0))) / t_2
else
tmp = ((t_1 * t_1) - t_0) / t_2
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = Math.pow(((hi * (hi / lo)) / (x - lo)), -2.0);
double t_1 = (x - lo) / hi;
double t_2 = t_1 * (1.0 - (lo / hi));
double t_3 = Math.pow(t_1, 2.0);
double tmp;
if (x <= -1.4) {
tmp = (Math.log(Math.exp(t_3)) - t_0) / t_2;
} else if (x <= 1.25) {
tmp = (t_3 - Math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2;
} else {
tmp = ((t_1 * t_1) - t_0) / t_2;
}
return tmp;
}
def code(lo, hi, x): t_0 = math.pow(((hi * (hi / lo)) / (x - lo)), -2.0) t_1 = (x - lo) / hi t_2 = t_1 * (1.0 - (lo / hi)) t_3 = math.pow(t_1, 2.0) tmp = 0 if x <= -1.4: tmp = (math.log(math.exp(t_3)) - t_0) / t_2 elif x <= 1.25: tmp = (t_3 - math.pow(((hi * hi) / (x * lo)), -2.0)) / t_2 else: tmp = ((t_1 * t_1) - t_0) / t_2 return tmp
function code(lo, hi, x) t_0 = Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) ^ -2.0 t_1 = Float64(Float64(x - lo) / hi) t_2 = Float64(t_1 * Float64(1.0 - Float64(lo / hi))) t_3 = t_1 ^ 2.0 tmp = 0.0 if (x <= -1.4) tmp = Float64(Float64(log(exp(t_3)) - t_0) / t_2); elseif (x <= 1.25) tmp = Float64(Float64(t_3 - (Float64(Float64(hi * hi) / Float64(x * lo)) ^ -2.0)) / t_2); else tmp = Float64(Float64(Float64(t_1 * t_1) - t_0) / t_2); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = ((hi * (hi / lo)) / (x - lo)) ^ -2.0; t_1 = (x - lo) / hi; t_2 = t_1 * (1.0 - (lo / hi)); t_3 = t_1 ^ 2.0; tmp = 0.0; if (x <= -1.4) tmp = (log(exp(t_3)) - t_0) / t_2; elseif (x <= 1.25) tmp = (t_3 - (((hi * hi) / (x * lo)) ^ -2.0)) / t_2; else tmp = ((t_1 * t_1) - t_0) / t_2; end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[Power[N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$1 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[t$95$1, 2.0], $MachinePrecision]}, If[LessEqual[x, -1.4], N[(N[(N[Log[N[Exp[t$95$3], $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[x, 1.25], N[(N[(t$95$3 - N[Power[N[(N[(hi * hi), $MachinePrecision] / N[(x * lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(t$95$1 * t$95$1), $MachinePrecision] - t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{hi \cdot \frac{hi}{lo}}{x - lo}\right)}^{-2}\\
t_1 := \frac{x - lo}{hi}\\
t_2 := t_1 \cdot \left(1 - \frac{lo}{hi}\right)\\
t_3 := {t_1}^{2}\\
\mathbf{if}\;x \leq -1.4:\\
\;\;\;\;\frac{\log \left(e^{t_3}\right) - t_0}{t_2}\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;\frac{t_3 - {\left(\frac{hi \cdot hi}{x \cdot lo}\right)}^{-2}}{t_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t_1 \cdot t_1 - t_0}{t_2}\\
\end{array}
\end{array}
if x < -1.3999999999999999Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
clear-num8.9%
clear-num8.9%
frac-times8.9%
metadata-eval8.9%
Applied egg-rr8.9%
+-commutative8.9%
flip-+8.9%
pow28.9%
inv-pow8.9%
inv-pow8.9%
pow-prod-up8.9%
associate-*l/32.9%
*-un-lft-identity32.9%
times-frac8.9%
/-rgt-identity8.9%
metadata-eval8.9%
Applied egg-rr8.9%
associate-*r/32.9%
*-rgt-identity32.9%
distribute-lft-out--32.9%
Simplified32.9%
add-log-exp32.9%
Applied egg-rr32.9%
if -1.3999999999999999 < x < 1.25Initial 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%
clear-num9.2%
clear-num9.2%
frac-times9.2%
metadata-eval9.2%
Applied egg-rr9.2%
+-commutative9.2%
flip-+9.2%
pow29.2%
inv-pow9.2%
inv-pow9.2%
pow-prod-up9.2%
associate-*l/29.9%
*-un-lft-identity29.9%
times-frac9.2%
/-rgt-identity9.2%
metadata-eval9.2%
Applied egg-rr9.2%
associate-*r/30.1%
*-rgt-identity30.1%
distribute-lft-out--30.1%
Simplified30.1%
Taylor expanded in lo around 0 99.2%
unpow299.2%
Simplified99.2%
if 1.25 < x Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.8%
div-sub8.8%
Simplified8.8%
clear-num8.8%
clear-num8.8%
frac-times8.8%
metadata-eval8.8%
Applied egg-rr8.8%
+-commutative8.8%
flip-+8.8%
pow28.8%
inv-pow8.8%
inv-pow8.8%
pow-prod-up8.8%
associate-*l/27.6%
*-un-lft-identity27.6%
times-frac8.8%
/-rgt-identity8.8%
metadata-eval8.8%
Applied egg-rr8.8%
associate-*r/27.7%
*-rgt-identity27.7%
distribute-lft-out--27.6%
Simplified27.6%
unpow227.6%
Applied egg-rr27.6%
Final simplification63.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)) (t_1 (* t_0 (- 1.0 (/ lo hi)))))
(if (or (<= x -1.55) (not (<= x 1.45)))
(/ (- (* t_0 t_0) (pow (/ (* hi (/ hi lo)) (- x lo)) -2.0)) t_1)
(/ (- (pow t_0 2.0) (pow (/ (* hi hi) (* x lo)) -2.0)) t_1))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = t_0 * (1.0 - (lo / hi));
double tmp;
if ((x <= -1.55) || !(x <= 1.45)) {
tmp = ((t_0 * t_0) - pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / t_1;
} else {
tmp = (pow(t_0, 2.0) - pow(((hi * hi) / (x * lo)), -2.0)) / t_1;
}
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) :: t_1
real(8) :: tmp
t_0 = (x - lo) / hi
t_1 = t_0 * (1.0d0 - (lo / hi))
if ((x <= (-1.55d0)) .or. (.not. (x <= 1.45d0))) then
tmp = ((t_0 * t_0) - (((hi * (hi / lo)) / (x - lo)) ** (-2.0d0))) / t_1
else
tmp = ((t_0 ** 2.0d0) - (((hi * hi) / (x * lo)) ** (-2.0d0))) / t_1
end if
code = tmp
end function
public static double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double t_1 = t_0 * (1.0 - (lo / hi));
double tmp;
if ((x <= -1.55) || !(x <= 1.45)) {
tmp = ((t_0 * t_0) - Math.pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / t_1;
} else {
tmp = (Math.pow(t_0, 2.0) - Math.pow(((hi * hi) / (x * lo)), -2.0)) / t_1;
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi t_1 = t_0 * (1.0 - (lo / hi)) tmp = 0 if (x <= -1.55) or not (x <= 1.45): tmp = ((t_0 * t_0) - math.pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / t_1 else: tmp = (math.pow(t_0, 2.0) - math.pow(((hi * hi) / (x * lo)), -2.0)) / t_1 return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) t_1 = Float64(t_0 * Float64(1.0 - Float64(lo / hi))) tmp = 0.0 if ((x <= -1.55) || !(x <= 1.45)) tmp = Float64(Float64(Float64(t_0 * t_0) - (Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) ^ -2.0)) / t_1); else tmp = Float64(Float64((t_0 ^ 2.0) - (Float64(Float64(hi * hi) / Float64(x * lo)) ^ -2.0)) / t_1); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; t_1 = t_0 * (1.0 - (lo / hi)); tmp = 0.0; if ((x <= -1.55) || ~((x <= 1.45))) tmp = ((t_0 * t_0) - (((hi * (hi / lo)) / (x - lo)) ^ -2.0)) / t_1; else tmp = ((t_0 ^ 2.0) - (((hi * hi) / (x * lo)) ^ -2.0)) / t_1; end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[x, -1.55], N[Not[LessEqual[x, 1.45]], $MachinePrecision]], N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[Power[N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[(N[Power[t$95$0, 2.0], $MachinePrecision] - N[Power[N[(N[(hi * hi), $MachinePrecision] / N[(x * lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
t_1 := t_0 \cdot \left(1 - \frac{lo}{hi}\right)\\
\mathbf{if}\;x \leq -1.55 \lor \neg \left(x \leq 1.45\right):\\
\;\;\;\;\frac{t_0 \cdot t_0 - {\left(\frac{hi \cdot \frac{hi}{lo}}{x - lo}\right)}^{-2}}{t_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{{t_0}^{2} - {\left(\frac{hi \cdot hi}{x \cdot lo}\right)}^{-2}}{t_1}\\
\end{array}
\end{array}
if x < -1.55000000000000004 or 1.44999999999999996 < x Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac8.9%
div-sub8.9%
Simplified8.9%
clear-num8.9%
clear-num8.9%
frac-times8.9%
metadata-eval8.9%
Applied egg-rr8.9%
+-commutative8.9%
flip-+8.9%
pow28.9%
inv-pow8.9%
inv-pow8.9%
pow-prod-up8.9%
associate-*l/29.8%
*-un-lft-identity29.8%
times-frac8.9%
/-rgt-identity8.9%
metadata-eval8.9%
Applied egg-rr8.9%
associate-*r/29.9%
*-rgt-identity29.9%
distribute-lft-out--29.8%
Simplified29.8%
unpow229.8%
Applied egg-rr29.8%
if -1.55000000000000004 < x < 1.44999999999999996Initial 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%
clear-num9.2%
clear-num9.2%
frac-times9.2%
metadata-eval9.2%
Applied egg-rr9.2%
+-commutative9.2%
flip-+9.2%
pow29.2%
inv-pow9.2%
inv-pow9.2%
pow-prod-up9.2%
associate-*l/29.9%
*-un-lft-identity29.9%
times-frac9.2%
/-rgt-identity9.2%
metadata-eval9.2%
Applied egg-rr9.2%
associate-*r/30.1%
*-rgt-identity30.1%
distribute-lft-out--30.1%
Simplified30.1%
Taylor expanded in lo around 0 99.2%
unpow299.2%
Simplified99.2%
Final simplification63.4%
(FPCore (lo hi x)
:precision binary64
(let* ((t_0 (/ (- x lo) hi)))
(if (<= hi 1.45875e+308)
1.0
(/
(- (* t_0 t_0) (pow (/ (* hi (/ hi lo)) (- x lo)) -2.0))
(* t_0 (- 1.0 (/ lo hi)))))))
double code(double lo, double hi, double x) {
double t_0 = (x - lo) / hi;
double tmp;
if (hi <= 1.45875e+308) {
tmp = 1.0;
} else {
tmp = ((t_0 * t_0) - pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / (t_0 * (1.0 - (lo / 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 (hi <= 1.45875d+308) then
tmp = 1.0d0
else
tmp = ((t_0 * t_0) - (((hi * (hi / lo)) / (x - lo)) ** (-2.0d0))) / (t_0 * (1.0d0 - (lo / 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 (hi <= 1.45875e+308) {
tmp = 1.0;
} else {
tmp = ((t_0 * t_0) - Math.pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / (t_0 * (1.0 - (lo / hi)));
}
return tmp;
}
def code(lo, hi, x): t_0 = (x - lo) / hi tmp = 0 if hi <= 1.45875e+308: tmp = 1.0 else: tmp = ((t_0 * t_0) - math.pow(((hi * (hi / lo)) / (x - lo)), -2.0)) / (t_0 * (1.0 - (lo / hi))) return tmp
function code(lo, hi, x) t_0 = Float64(Float64(x - lo) / hi) tmp = 0.0 if (hi <= 1.45875e+308) tmp = 1.0; else tmp = Float64(Float64(Float64(t_0 * t_0) - (Float64(Float64(hi * Float64(hi / lo)) / Float64(x - lo)) ^ -2.0)) / Float64(t_0 * Float64(1.0 - Float64(lo / hi)))); end return tmp end
function tmp_2 = code(lo, hi, x) t_0 = (x - lo) / hi; tmp = 0.0; if (hi <= 1.45875e+308) tmp = 1.0; else tmp = ((t_0 * t_0) - (((hi * (hi / lo)) / (x - lo)) ^ -2.0)) / (t_0 * (1.0 - (lo / hi))); end tmp_2 = tmp; end
code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, If[LessEqual[hi, 1.45875e+308], 1.0, N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[Power[N[(N[(hi * N[(hi / lo), $MachinePrecision]), $MachinePrecision] / N[(x - lo), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * N[(1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - lo}{hi}\\
\mathbf{if}\;hi \leq 1.45875 \cdot 10^{+308}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;\frac{t_0 \cdot t_0 - {\left(\frac{hi \cdot \frac{hi}{lo}}{x - lo}\right)}^{-2}}{t_0 \cdot \left(1 - \frac{lo}{hi}\right)}\\
\end{array}
\end{array}
if hi < 1.45875000000000008e308Initial program 3.1%
Taylor expanded in lo around inf 18.9%
if 1.45875000000000008e308 < hi Initial program 3.1%
Taylor expanded in hi around inf 0.0%
+-commutative0.0%
associate--l+0.0%
*-commutative0.0%
unpow20.0%
times-frac13.0%
div-sub13.0%
Simplified13.0%
clear-num13.0%
clear-num13.0%
frac-times13.0%
metadata-eval13.0%
Applied egg-rr13.0%
+-commutative13.0%
flip-+13.0%
pow213.0%
inv-pow13.0%
inv-pow13.0%
pow-prod-up13.0%
associate-*l/56.1%
*-un-lft-identity56.1%
times-frac13.0%
/-rgt-identity13.0%
metadata-eval13.0%
Applied egg-rr13.0%
associate-*r/56.4%
*-rgt-identity56.4%
distribute-lft-out--56.3%
Simplified56.3%
unpow256.3%
Applied egg-rr56.3%
Final simplification36.4%
(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 2023257
(FPCore (lo hi x)
:name "xlohi (overflows)"
:precision binary64
:pre (and (< lo -1e+308) (> hi 1e+308))
(/ (- x lo) (- hi lo)))