
(FPCore (a b eps) :precision binary64 (/ (* eps (- (exp (* (+ a b) eps)) 1.0)) (* (- (exp (* a eps)) 1.0) (- (exp (* b eps)) 1.0))))
double code(double a, double b, double eps) {
return (eps * (exp(((a + b) * eps)) - 1.0)) / ((exp((a * eps)) - 1.0) * (exp((b * eps)) - 1.0));
}
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = (eps * (exp(((a + b) * eps)) - 1.0d0)) / ((exp((a * eps)) - 1.0d0) * (exp((b * eps)) - 1.0d0))
end function
public static double code(double a, double b, double eps) {
return (eps * (Math.exp(((a + b) * eps)) - 1.0)) / ((Math.exp((a * eps)) - 1.0) * (Math.exp((b * eps)) - 1.0));
}
def code(a, b, eps): return (eps * (math.exp(((a + b) * eps)) - 1.0)) / ((math.exp((a * eps)) - 1.0) * (math.exp((b * eps)) - 1.0))
function code(a, b, eps) return Float64(Float64(eps * Float64(exp(Float64(Float64(a + b) * eps)) - 1.0)) / Float64(Float64(exp(Float64(a * eps)) - 1.0) * Float64(exp(Float64(b * eps)) - 1.0))) end
function tmp = code(a, b, eps) tmp = (eps * (exp(((a + b) * eps)) - 1.0)) / ((exp((a * eps)) - 1.0) * (exp((b * eps)) - 1.0)); end
code[a_, b_, eps_] := N[(N[(eps * N[(N[Exp[N[(N[(a + b), $MachinePrecision] * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Exp[N[(a * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision] * N[(N[Exp[N[(b * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\varepsilon \cdot \left(e^{\left(a + b\right) \cdot \varepsilon} - 1\right)}{\left(e^{a \cdot \varepsilon} - 1\right) \cdot \left(e^{b \cdot \varepsilon} - 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b eps) :precision binary64 (/ (* eps (- (exp (* (+ a b) eps)) 1.0)) (* (- (exp (* a eps)) 1.0) (- (exp (* b eps)) 1.0))))
double code(double a, double b, double eps) {
return (eps * (exp(((a + b) * eps)) - 1.0)) / ((exp((a * eps)) - 1.0) * (exp((b * eps)) - 1.0));
}
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = (eps * (exp(((a + b) * eps)) - 1.0d0)) / ((exp((a * eps)) - 1.0d0) * (exp((b * eps)) - 1.0d0))
end function
public static double code(double a, double b, double eps) {
return (eps * (Math.exp(((a + b) * eps)) - 1.0)) / ((Math.exp((a * eps)) - 1.0) * (Math.exp((b * eps)) - 1.0));
}
def code(a, b, eps): return (eps * (math.exp(((a + b) * eps)) - 1.0)) / ((math.exp((a * eps)) - 1.0) * (math.exp((b * eps)) - 1.0))
function code(a, b, eps) return Float64(Float64(eps * Float64(exp(Float64(Float64(a + b) * eps)) - 1.0)) / Float64(Float64(exp(Float64(a * eps)) - 1.0) * Float64(exp(Float64(b * eps)) - 1.0))) end
function tmp = code(a, b, eps) tmp = (eps * (exp(((a + b) * eps)) - 1.0)) / ((exp((a * eps)) - 1.0) * (exp((b * eps)) - 1.0)); end
code[a_, b_, eps_] := N[(N[(eps * N[(N[Exp[N[(N[(a + b), $MachinePrecision] * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Exp[N[(a * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision] * N[(N[Exp[N[(b * eps), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\varepsilon \cdot \left(e^{\left(a + b\right) \cdot \varepsilon} - 1\right)}{\left(e^{a \cdot \varepsilon} - 1\right) \cdot \left(e^{b \cdot \varepsilon} - 1\right)}
\end{array}
NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b eps)
:precision binary64
(let* ((t_0 (/ (expm1 (* eps (+ b a))) (expm1 (* b eps)))))
(if (<= b -2.6e+23)
(* (/ eps (expm1 (* eps a))) t_0)
(if (<= b 1.8e+108)
(/ (+ (/ b a) 1.0) b)
(* t_0 (+ (* eps -0.5) (/ 1.0 a)))))))assert(a < b);
double code(double a, double b, double eps) {
double t_0 = expm1((eps * (b + a))) / expm1((b * eps));
double tmp;
if (b <= -2.6e+23) {
tmp = (eps / expm1((eps * a))) * t_0;
} else if (b <= 1.8e+108) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = t_0 * ((eps * -0.5) + (1.0 / a));
}
return tmp;
}
assert a < b;
public static double code(double a, double b, double eps) {
double t_0 = Math.expm1((eps * (b + a))) / Math.expm1((b * eps));
double tmp;
if (b <= -2.6e+23) {
tmp = (eps / Math.expm1((eps * a))) * t_0;
} else if (b <= 1.8e+108) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = t_0 * ((eps * -0.5) + (1.0 / a));
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): t_0 = math.expm1((eps * (b + a))) / math.expm1((b * eps)) tmp = 0 if b <= -2.6e+23: tmp = (eps / math.expm1((eps * a))) * t_0 elif b <= 1.8e+108: tmp = ((b / a) + 1.0) / b else: tmp = t_0 * ((eps * -0.5) + (1.0 / a)) return tmp
a, b = sort([a, b]) function code(a, b, eps) t_0 = Float64(expm1(Float64(eps * Float64(b + a))) / expm1(Float64(b * eps))) tmp = 0.0 if (b <= -2.6e+23) tmp = Float64(Float64(eps / expm1(Float64(eps * a))) * t_0); elseif (b <= 1.8e+108) tmp = Float64(Float64(Float64(b / a) + 1.0) / b); else tmp = Float64(t_0 * Float64(Float64(eps * -0.5) + Float64(1.0 / a))); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function.
code[a_, b_, eps_] := Block[{t$95$0 = N[(N[(Exp[N[(eps * N[(b + a), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] / N[(Exp[N[(b * eps), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.6e+23], N[(N[(eps / N[(Exp[N[(eps * a), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[b, 1.8e+108], N[(N[(N[(b / a), $MachinePrecision] + 1.0), $MachinePrecision] / b), $MachinePrecision], N[(t$95$0 * N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
t_0 := \frac{\mathsf{expm1}\left(\varepsilon \cdot \left(b + a\right)\right)}{\mathsf{expm1}\left(b \cdot \varepsilon\right)}\\
\mathbf{if}\;b \leq -2.6 \cdot 10^{+23}:\\
\;\;\;\;\frac{\varepsilon}{\mathsf{expm1}\left(\varepsilon \cdot a\right)} \cdot t_0\\
\mathbf{elif}\;b \leq 1.8 \cdot 10^{+108}:\\
\;\;\;\;\frac{\frac{b}{a} + 1}{b}\\
\mathbf{else}:\\
\;\;\;\;t_0 \cdot \left(\varepsilon \cdot -0.5 + \frac{1}{a}\right)\\
\end{array}
\end{array}
if b < -2.59999999999999992e23Initial program 26.2%
times-frac26.2%
expm1-def46.1%
*-commutative46.1%
expm1-def43.1%
*-commutative43.1%
expm1-def79.8%
*-commutative79.8%
Simplified79.8%
if -2.59999999999999992e23 < b < 1.8e108Initial program 1.2%
times-frac1.2%
expm1-def1.8%
*-commutative1.8%
expm1-def3.9%
*-commutative3.9%
expm1-def50.1%
*-commutative50.1%
Simplified50.1%
Taylor expanded in eps around 0 49.2%
Taylor expanded in eps around 0 99.3%
if 1.8e108 < b Initial program 14.8%
times-frac14.8%
expm1-def43.2%
*-commutative43.2%
expm1-def42.8%
*-commutative42.8%
expm1-def68.1%
*-commutative68.1%
Simplified68.1%
Taylor expanded in eps around 0 92.8%
Final simplification94.2%
NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b eps)
:precision binary64
(let* ((t_0 (expm1 (* b eps))))
(if (<= b -2.6e+23)
(/ eps t_0)
(if (<= b 7.5e+106)
(/ (+ (/ b a) 1.0) b)
(* (/ (expm1 (* eps (+ b a))) t_0) (+ (* eps -0.5) (/ 1.0 a)))))))assert(a < b);
double code(double a, double b, double eps) {
double t_0 = expm1((b * eps));
double tmp;
if (b <= -2.6e+23) {
tmp = eps / t_0;
} else if (b <= 7.5e+106) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (expm1((eps * (b + a))) / t_0) * ((eps * -0.5) + (1.0 / a));
}
return tmp;
}
assert a < b;
public static double code(double a, double b, double eps) {
double t_0 = Math.expm1((b * eps));
double tmp;
if (b <= -2.6e+23) {
tmp = eps / t_0;
} else if (b <= 7.5e+106) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (Math.expm1((eps * (b + a))) / t_0) * ((eps * -0.5) + (1.0 / a));
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): t_0 = math.expm1((b * eps)) tmp = 0 if b <= -2.6e+23: tmp = eps / t_0 elif b <= 7.5e+106: tmp = ((b / a) + 1.0) / b else: tmp = (math.expm1((eps * (b + a))) / t_0) * ((eps * -0.5) + (1.0 / a)) return tmp
a, b = sort([a, b]) function code(a, b, eps) t_0 = expm1(Float64(b * eps)) tmp = 0.0 if (b <= -2.6e+23) tmp = Float64(eps / t_0); elseif (b <= 7.5e+106) tmp = Float64(Float64(Float64(b / a) + 1.0) / b); else tmp = Float64(Float64(expm1(Float64(eps * Float64(b + a))) / t_0) * Float64(Float64(eps * -0.5) + Float64(1.0 / a))); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function.
code[a_, b_, eps_] := Block[{t$95$0 = N[(Exp[N[(b * eps), $MachinePrecision]] - 1), $MachinePrecision]}, If[LessEqual[b, -2.6e+23], N[(eps / t$95$0), $MachinePrecision], If[LessEqual[b, 7.5e+106], N[(N[(N[(b / a), $MachinePrecision] + 1.0), $MachinePrecision] / b), $MachinePrecision], N[(N[(N[(Exp[N[(eps * N[(b + a), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
t_0 := \mathsf{expm1}\left(b \cdot \varepsilon\right)\\
\mathbf{if}\;b \leq -2.6 \cdot 10^{+23}:\\
\;\;\;\;\frac{\varepsilon}{t_0}\\
\mathbf{elif}\;b \leq 7.5 \cdot 10^{+106}:\\
\;\;\;\;\frac{\frac{b}{a} + 1}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{expm1}\left(\varepsilon \cdot \left(b + a\right)\right)}{t_0} \cdot \left(\varepsilon \cdot -0.5 + \frac{1}{a}\right)\\
\end{array}
\end{array}
if b < -2.59999999999999992e23Initial program 26.2%
expm1-def26.7%
*-commutative26.7%
expm1-def42.7%
*-commutative42.7%
expm1-def72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in a around inf 27.1%
Taylor expanded in eps around inf 21.0%
expm1-def31.6%
*-commutative31.6%
Simplified31.6%
if -2.59999999999999992e23 < b < 7.50000000000000058e106Initial program 1.2%
times-frac1.2%
expm1-def1.8%
*-commutative1.8%
expm1-def3.9%
*-commutative3.9%
expm1-def50.1%
*-commutative50.1%
Simplified50.1%
Taylor expanded in eps around 0 49.2%
Taylor expanded in eps around 0 99.3%
if 7.50000000000000058e106 < b Initial program 14.8%
times-frac14.8%
expm1-def43.2%
*-commutative43.2%
expm1-def42.8%
*-commutative42.8%
expm1-def68.1%
*-commutative68.1%
Simplified68.1%
Taylor expanded in eps around 0 92.8%
Final simplification83.6%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (if (<= b -2.6e+23) (/ eps (expm1 (* b eps))) (if (<= b 6e+78) (/ (+ (/ b a) 1.0) b) (+ (* eps -0.5) (/ 1.0 a)))))
assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= -2.6e+23) {
tmp = eps / expm1((b * eps));
} else if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (eps * -0.5) + (1.0 / a);
}
return tmp;
}
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= -2.6e+23) {
tmp = eps / Math.expm1((b * eps));
} else if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (eps * -0.5) + (1.0 / a);
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= -2.6e+23: tmp = eps / math.expm1((b * eps)) elif b <= 6e+78: tmp = ((b / a) + 1.0) / b else: tmp = (eps * -0.5) + (1.0 / a) return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= -2.6e+23) tmp = Float64(eps / expm1(Float64(b * eps))); elseif (b <= 6e+78) tmp = Float64(Float64(Float64(b / a) + 1.0) / b); else tmp = Float64(Float64(eps * -0.5) + Float64(1.0 / a)); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, -2.6e+23], N[(eps / N[(Exp[N[(b * eps), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6e+78], N[(N[(N[(b / a), $MachinePrecision] + 1.0), $MachinePrecision] / b), $MachinePrecision], N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.6 \cdot 10^{+23}:\\
\;\;\;\;\frac{\varepsilon}{\mathsf{expm1}\left(b \cdot \varepsilon\right)}\\
\mathbf{elif}\;b \leq 6 \cdot 10^{+78}:\\
\;\;\;\;\frac{\frac{b}{a} + 1}{b}\\
\mathbf{else}:\\
\;\;\;\;\varepsilon \cdot -0.5 + \frac{1}{a}\\
\end{array}
\end{array}
if b < -2.59999999999999992e23Initial program 26.2%
expm1-def26.7%
*-commutative26.7%
expm1-def42.7%
*-commutative42.7%
expm1-def72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in a around inf 27.1%
Taylor expanded in eps around inf 21.0%
expm1-def31.6%
*-commutative31.6%
Simplified31.6%
if -2.59999999999999992e23 < b < 5.99999999999999964e78Initial program 1.3%
times-frac1.3%
expm1-def1.9%
*-commutative1.9%
expm1-def4.0%
*-commutative4.0%
expm1-def50.7%
*-commutative50.7%
Simplified50.7%
Taylor expanded in eps around 0 48.6%
Taylor expanded in eps around 0 99.3%
if 5.99999999999999964e78 < b Initial program 13.3%
times-frac13.3%
expm1-def38.6%
*-commutative38.6%
expm1-def38.5%
*-commutative38.5%
expm1-def63.8%
*-commutative63.8%
Simplified63.8%
Taylor expanded in a around 0 58.1%
Taylor expanded in eps around 0 87.3%
Final simplification82.7%
NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b eps)
:precision binary64
(if (<= b 9.2e-176)
(+ (* eps -0.5) (/ 1.0 b))
(if (<= b 2.3e-158)
(/ 1.0 a)
(if (<= b 2.05e+271) (/ (+ b a) (* b a)) (/ 1.0 a)))))assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = (eps * -0.5) + (1.0 / b);
} else if (b <= 2.3e-158) {
tmp = 1.0 / a;
} else if (b <= 2.05e+271) {
tmp = (b + a) / (b * a);
} else {
tmp = 1.0 / a;
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
real(8) :: tmp
if (b <= 9.2d-176) then
tmp = (eps * (-0.5d0)) + (1.0d0 / b)
else if (b <= 2.3d-158) then
tmp = 1.0d0 / a
else if (b <= 2.05d+271) then
tmp = (b + a) / (b * a)
else
tmp = 1.0d0 / a
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = (eps * -0.5) + (1.0 / b);
} else if (b <= 2.3e-158) {
tmp = 1.0 / a;
} else if (b <= 2.05e+271) {
tmp = (b + a) / (b * a);
} else {
tmp = 1.0 / a;
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= 9.2e-176: tmp = (eps * -0.5) + (1.0 / b) elif b <= 2.3e-158: tmp = 1.0 / a elif b <= 2.05e+271: tmp = (b + a) / (b * a) else: tmp = 1.0 / a return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= 9.2e-176) tmp = Float64(Float64(eps * -0.5) + Float64(1.0 / b)); elseif (b <= 2.3e-158) tmp = Float64(1.0 / a); elseif (b <= 2.05e+271) tmp = Float64(Float64(b + a) / Float64(b * a)); else tmp = Float64(1.0 / a); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b, eps)
tmp = 0.0;
if (b <= 9.2e-176)
tmp = (eps * -0.5) + (1.0 / b);
elseif (b <= 2.3e-158)
tmp = 1.0 / a;
elseif (b <= 2.05e+271)
tmp = (b + a) / (b * a);
else
tmp = 1.0 / a;
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, 9.2e-176], N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.3e-158], N[(1.0 / a), $MachinePrecision], If[LessEqual[b, 2.05e+271], N[(N[(b + a), $MachinePrecision] / N[(b * a), $MachinePrecision]), $MachinePrecision], N[(1.0 / a), $MachinePrecision]]]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq 9.2 \cdot 10^{-176}:\\
\;\;\;\;\varepsilon \cdot -0.5 + \frac{1}{b}\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{-158}:\\
\;\;\;\;\frac{1}{a}\\
\mathbf{elif}\;b \leq 2.05 \cdot 10^{+271}:\\
\;\;\;\;\frac{b + a}{b \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a}\\
\end{array}
\end{array}
if b < 9.2000000000000005e-176Initial program 9.2%
expm1-def9.9%
*-commutative9.9%
expm1-def15.4%
*-commutative15.4%
expm1-def37.1%
*-commutative37.1%
Simplified37.1%
Taylor expanded in a around inf 20.9%
Taylor expanded in eps around 0 58.1%
if 9.2000000000000005e-176 < b < 2.2999999999999999e-158 or 2.05000000000000012e271 < b Initial program 6.2%
associate-*l/6.2%
*-commutative6.2%
expm1-def7.0%
*-commutative7.0%
expm1-def46.2%
*-commutative46.2%
expm1-def55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in a around 0 84.9%
if 2.2999999999999999e-158 < b < 2.05000000000000012e271Initial program 7.3%
associate-*l/7.3%
*-commutative7.3%
expm1-def8.9%
*-commutative8.9%
expm1-def15.3%
*-commutative15.3%
expm1-def44.1%
*-commutative44.1%
Simplified44.1%
Taylor expanded in eps around 0 85.0%
Final simplification67.3%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (if (<= b 9.2e-176) (+ (* eps -0.5) (/ 1.0 b)) (/ 1.0 a)))
assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = (eps * -0.5) + (1.0 / b);
} else {
tmp = 1.0 / a;
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
real(8) :: tmp
if (b <= 9.2d-176) then
tmp = (eps * (-0.5d0)) + (1.0d0 / b)
else
tmp = 1.0d0 / a
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = (eps * -0.5) + (1.0 / b);
} else {
tmp = 1.0 / a;
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= 9.2e-176: tmp = (eps * -0.5) + (1.0 / b) else: tmp = 1.0 / a return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= 9.2e-176) tmp = Float64(Float64(eps * -0.5) + Float64(1.0 / b)); else tmp = Float64(1.0 / a); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b, eps)
tmp = 0.0;
if (b <= 9.2e-176)
tmp = (eps * -0.5) + (1.0 / b);
else
tmp = 1.0 / a;
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, 9.2e-176], N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / b), $MachinePrecision]), $MachinePrecision], N[(1.0 / a), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq 9.2 \cdot 10^{-176}:\\
\;\;\;\;\varepsilon \cdot -0.5 + \frac{1}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a}\\
\end{array}
\end{array}
if b < 9.2000000000000005e-176Initial program 9.2%
expm1-def9.9%
*-commutative9.9%
expm1-def15.4%
*-commutative15.4%
expm1-def37.1%
*-commutative37.1%
Simplified37.1%
Taylor expanded in a around inf 20.9%
Taylor expanded in eps around 0 58.1%
if 9.2000000000000005e-176 < b Initial program 7.1%
associate-*l/7.1%
*-commutative7.1%
expm1-def8.6%
*-commutative8.6%
expm1-def20.2%
*-commutative20.2%
expm1-def45.8%
*-commutative45.8%
Simplified45.8%
Taylor expanded in a around 0 63.9%
Final simplification60.1%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (if (<= b 6e+78) (/ (+ (/ b a) 1.0) b) (/ 1.0 a)))
assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
real(8) :: tmp
if (b <= 6d+78) then
tmp = ((b / a) + 1.0d0) / b
else
tmp = 1.0d0 / a
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= 6e+78: tmp = ((b / a) + 1.0) / b else: tmp = 1.0 / a return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= 6e+78) tmp = Float64(Float64(Float64(b / a) + 1.0) / b); else tmp = Float64(1.0 / a); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b, eps)
tmp = 0.0;
if (b <= 6e+78)
tmp = ((b / a) + 1.0) / b;
else
tmp = 1.0 / a;
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, 6e+78], N[(N[(N[(b / a), $MachinePrecision] + 1.0), $MachinePrecision] / b), $MachinePrecision], N[(1.0 / a), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq 6 \cdot 10^{+78}:\\
\;\;\;\;\frac{\frac{b}{a} + 1}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a}\\
\end{array}
\end{array}
if b < 5.99999999999999964e78Initial program 7.7%
times-frac7.7%
expm1-def13.2%
*-commutative13.2%
expm1-def14.0%
*-commutative14.0%
expm1-def58.2%
*-commutative58.2%
Simplified58.2%
Taylor expanded in eps around 0 54.7%
Taylor expanded in eps around 0 88.0%
if 5.99999999999999964e78 < b Initial program 13.3%
associate-*l/13.3%
*-commutative13.3%
expm1-def14.8%
*-commutative14.8%
expm1-def38.5%
*-commutative38.5%
expm1-def57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in a around 0 86.3%
Final simplification87.8%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (if (<= b 6e+78) (/ (+ (/ b a) 1.0) b) (+ (* eps -0.5) (/ 1.0 a))))
assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (eps * -0.5) + (1.0 / a);
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
real(8) :: tmp
if (b <= 6d+78) then
tmp = ((b / a) + 1.0d0) / b
else
tmp = (eps * (-0.5d0)) + (1.0d0 / a)
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= 6e+78) {
tmp = ((b / a) + 1.0) / b;
} else {
tmp = (eps * -0.5) + (1.0 / a);
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= 6e+78: tmp = ((b / a) + 1.0) / b else: tmp = (eps * -0.5) + (1.0 / a) return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= 6e+78) tmp = Float64(Float64(Float64(b / a) + 1.0) / b); else tmp = Float64(Float64(eps * -0.5) + Float64(1.0 / a)); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b, eps)
tmp = 0.0;
if (b <= 6e+78)
tmp = ((b / a) + 1.0) / b;
else
tmp = (eps * -0.5) + (1.0 / a);
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, 6e+78], N[(N[(N[(b / a), $MachinePrecision] + 1.0), $MachinePrecision] / b), $MachinePrecision], N[(N[(eps * -0.5), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq 6 \cdot 10^{+78}:\\
\;\;\;\;\frac{\frac{b}{a} + 1}{b}\\
\mathbf{else}:\\
\;\;\;\;\varepsilon \cdot -0.5 + \frac{1}{a}\\
\end{array}
\end{array}
if b < 5.99999999999999964e78Initial program 7.7%
times-frac7.7%
expm1-def13.2%
*-commutative13.2%
expm1-def14.0%
*-commutative14.0%
expm1-def58.2%
*-commutative58.2%
Simplified58.2%
Taylor expanded in eps around 0 54.7%
Taylor expanded in eps around 0 88.0%
if 5.99999999999999964e78 < b Initial program 13.3%
times-frac13.3%
expm1-def38.6%
*-commutative38.6%
expm1-def38.5%
*-commutative38.5%
expm1-def63.8%
*-commutative63.8%
Simplified63.8%
Taylor expanded in a around 0 58.1%
Taylor expanded in eps around 0 87.3%
Final simplification87.9%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (if (<= b 9.2e-176) (/ 1.0 b) (/ 1.0 a)))
assert(a < b);
double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = 1.0 / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
real(8) :: tmp
if (b <= 9.2d-176) then
tmp = 1.0d0 / b
else
tmp = 1.0d0 / a
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b, double eps) {
double tmp;
if (b <= 9.2e-176) {
tmp = 1.0 / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b, eps): tmp = 0 if b <= 9.2e-176: tmp = 1.0 / b else: tmp = 1.0 / a return tmp
a, b = sort([a, b]) function code(a, b, eps) tmp = 0.0 if (b <= 9.2e-176) tmp = Float64(1.0 / b); else tmp = Float64(1.0 / a); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b, eps)
tmp = 0.0;
if (b <= 9.2e-176)
tmp = 1.0 / b;
else
tmp = 1.0 / a;
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := If[LessEqual[b, 9.2e-176], N[(1.0 / b), $MachinePrecision], N[(1.0 / a), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;b \leq 9.2 \cdot 10^{-176}:\\
\;\;\;\;\frac{1}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a}\\
\end{array}
\end{array}
if b < 9.2000000000000005e-176Initial program 9.2%
associate-*l/9.2%
*-commutative9.2%
expm1-def10.7%
*-commutative10.7%
expm1-def16.3%
*-commutative16.3%
expm1-def38.6%
*-commutative38.6%
Simplified38.6%
Taylor expanded in b around 0 57.2%
if 9.2000000000000005e-176 < b Initial program 7.1%
associate-*l/7.1%
*-commutative7.1%
expm1-def8.6%
*-commutative8.6%
expm1-def20.2%
*-commutative20.2%
expm1-def45.8%
*-commutative45.8%
Simplified45.8%
Taylor expanded in a around 0 63.9%
Final simplification59.5%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b eps) :precision binary64 (/ 1.0 a))
assert(a < b);
double code(double a, double b, double eps) {
return 1.0 / a;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = 1.0d0 / a
end function
assert a < b;
public static double code(double a, double b, double eps) {
return 1.0 / a;
}
[a, b] = sort([a, b]) def code(a, b, eps): return 1.0 / a
a, b = sort([a, b]) function code(a, b, eps) return Float64(1.0 / a) end
a, b = num2cell(sort([a, b])){:}
function tmp = code(a, b, eps)
tmp = 1.0 / a;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_, eps_] := N[(1.0 / a), $MachinePrecision]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\frac{1}{a}
\end{array}
Initial program 8.5%
associate-*l/8.5%
*-commutative8.5%
expm1-def9.9%
*-commutative9.9%
expm1-def17.7%
*-commutative17.7%
expm1-def41.1%
*-commutative41.1%
Simplified41.1%
Taylor expanded in a around 0 46.2%
Final simplification46.2%
(FPCore (a b eps) :precision binary64 (/ (+ a b) (* a b)))
double code(double a, double b, double eps) {
return (a + b) / (a * b);
}
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = (a + b) / (a * b)
end function
public static double code(double a, double b, double eps) {
return (a + b) / (a * b);
}
def code(a, b, eps): return (a + b) / (a * b)
function code(a, b, eps) return Float64(Float64(a + b) / Float64(a * b)) end
function tmp = code(a, b, eps) tmp = (a + b) / (a * b); end
code[a_, b_, eps_] := N[(N[(a + b), $MachinePrecision] / N[(a * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a + b}{a \cdot b}
\end{array}
herbie shell --seed 2023187
(FPCore (a b eps)
:name "expq3 (problem 3.4.2)"
:precision binary64
:pre (and (< -1.0 eps) (< eps 1.0))
:herbie-target
(/ (+ a b) (* a b))
(/ (* eps (- (exp (* (+ a b) eps)) 1.0)) (* (- (exp (* a eps)) 1.0) (- (exp (* b eps)) 1.0))))