
(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 6 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}
(FPCore (a b eps) :precision binary64 (- (+ (+ (* 0.5 eps) (/ 1.0 b)) (/ 1.0 a)) (* 0.5 eps)))
double code(double a, double b, double eps) {
return (((0.5 * eps) + (1.0 / b)) + (1.0 / a)) - (0.5 * eps);
}
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = (((0.5d0 * eps) + (1.0d0 / b)) + (1.0d0 / a)) - (0.5d0 * eps)
end function
public static double code(double a, double b, double eps) {
return (((0.5 * eps) + (1.0 / b)) + (1.0 / a)) - (0.5 * eps);
}
def code(a, b, eps): return (((0.5 * eps) + (1.0 / b)) + (1.0 / a)) - (0.5 * eps)
function code(a, b, eps) return Float64(Float64(Float64(Float64(0.5 * eps) + Float64(1.0 / b)) + Float64(1.0 / a)) - Float64(0.5 * eps)) end
function tmp = code(a, b, eps) tmp = (((0.5 * eps) + (1.0 / b)) + (1.0 / a)) - (0.5 * eps); end
code[a_, b_, eps_] := N[(N[(N[(N[(0.5 * eps), $MachinePrecision] + N[(1.0 / b), $MachinePrecision]), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(0.5 * eps), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(0.5 \cdot \varepsilon + \frac{1}{b}\right) + \frac{1}{a}\right) - 0.5 \cdot \varepsilon
\end{array}
Initial program 6.3%
*-commutative6.3%
associate-*l/6.3%
*-commutative6.3%
expm1-def7.9%
*-commutative7.9%
associate-/r*7.9%
expm1-def18.5%
*-commutative18.5%
expm1-def47.7%
*-commutative47.7%
Simplified47.7%
Taylor expanded in a around 0 15.0%
Taylor expanded in eps around 0 98.3%
Final simplification98.3%
(FPCore (a b eps) :precision binary64 (- (+ (/ 1.0 b) (/ 1.0 a)) (* 0.5 eps)))
double code(double a, double b, double eps) {
return ((1.0 / b) + (1.0 / a)) - (0.5 * eps);
}
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 / b) + (1.0d0 / a)) - (0.5d0 * eps)
end function
public static double code(double a, double b, double eps) {
return ((1.0 / b) + (1.0 / a)) - (0.5 * eps);
}
def code(a, b, eps): return ((1.0 / b) + (1.0 / a)) - (0.5 * eps)
function code(a, b, eps) return Float64(Float64(Float64(1.0 / b) + Float64(1.0 / a)) - Float64(0.5 * eps)) end
function tmp = code(a, b, eps) tmp = ((1.0 / b) + (1.0 / a)) - (0.5 * eps); end
code[a_, b_, eps_] := N[(N[(N[(1.0 / b), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(0.5 * eps), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{1}{b} + \frac{1}{a}\right) - 0.5 \cdot \varepsilon
\end{array}
Initial program 6.3%
*-commutative6.3%
times-frac6.3%
+-commutative6.3%
expm1-def17.9%
*-commutative17.9%
expm1-def18.5%
+-commutative18.5%
*-commutative18.5%
expm1-def53.3%
*-commutative53.3%
Simplified53.3%
Taylor expanded in eps around 0 54.7%
Taylor expanded in b around 0 95.1%
Final simplification95.1%
(FPCore (a b eps) :precision binary64 (+ (/ 1.0 b) (/ 1.0 a)))
double code(double a, double b, double eps) {
return (1.0 / b) + (1.0 / a);
}
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 / b) + (1.0d0 / a)
end function
public static double code(double a, double b, double eps) {
return (1.0 / b) + (1.0 / a);
}
def code(a, b, eps): return (1.0 / b) + (1.0 / a)
function code(a, b, eps) return Float64(Float64(1.0 / b) + Float64(1.0 / a)) end
function tmp = code(a, b, eps) tmp = (1.0 / b) + (1.0 / a); end
code[a_, b_, eps_] := N[(N[(1.0 / b), $MachinePrecision] + N[(1.0 / a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{b} + \frac{1}{a}
\end{array}
Initial program 6.3%
*-commutative6.3%
associate-*l/6.3%
*-commutative6.3%
expm1-def7.9%
*-commutative7.9%
associate-/r*7.9%
expm1-def18.5%
*-commutative18.5%
expm1-def47.7%
*-commutative47.7%
Simplified47.7%
Taylor expanded in eps around 0 78.5%
Taylor expanded in a around 0 95.0%
Final simplification95.0%
(FPCore (a b eps) :precision binary64 (if (<= a -1.9e-112) (/ 1.0 b) (/ 1.0 a)))
double code(double a, double b, double eps) {
double tmp;
if (a <= -1.9e-112) {
tmp = 1.0 / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
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 (a <= (-1.9d-112)) then
tmp = 1.0d0 / b
else
tmp = 1.0d0 / a
end if
code = tmp
end function
public static double code(double a, double b, double eps) {
double tmp;
if (a <= -1.9e-112) {
tmp = 1.0 / b;
} else {
tmp = 1.0 / a;
}
return tmp;
}
def code(a, b, eps): tmp = 0 if a <= -1.9e-112: tmp = 1.0 / b else: tmp = 1.0 / a return tmp
function code(a, b, eps) tmp = 0.0 if (a <= -1.9e-112) tmp = Float64(1.0 / b); else tmp = Float64(1.0 / a); end return tmp end
function tmp_2 = code(a, b, eps) tmp = 0.0; if (a <= -1.9e-112) tmp = 1.0 / b; else tmp = 1.0 / a; end tmp_2 = tmp; end
code[a_, b_, eps_] := If[LessEqual[a, -1.9e-112], N[(1.0 / b), $MachinePrecision], N[(1.0 / a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.9 \cdot 10^{-112}:\\
\;\;\;\;\frac{1}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a}\\
\end{array}
\end{array}
if a < -1.89999999999999997e-112Initial program 8.8%
*-commutative8.8%
associate-*l/8.8%
*-commutative8.8%
expm1-def10.3%
*-commutative10.3%
associate-/r*10.3%
expm1-def28.1%
*-commutative28.1%
expm1-def69.3%
*-commutative69.3%
Simplified69.3%
Taylor expanded in b around 0 66.1%
if -1.89999999999999997e-112 < a Initial program 5.3%
*-commutative5.3%
associate-*l/5.3%
*-commutative5.3%
expm1-def6.9%
*-commutative6.9%
associate-/r*6.9%
expm1-def14.5%
*-commutative14.5%
expm1-def38.5%
*-commutative38.5%
Simplified38.5%
Taylor expanded in a around 0 58.4%
Final simplification60.7%
(FPCore (a b eps) :precision binary64 (* eps -0.5))
double code(double a, double b, double eps) {
return eps * -0.5;
}
real(8) function code(a, b, eps)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: eps
code = eps * (-0.5d0)
end function
public static double code(double a, double b, double eps) {
return eps * -0.5;
}
def code(a, b, eps): return eps * -0.5
function code(a, b, eps) return Float64(eps * -0.5) end
function tmp = code(a, b, eps) tmp = eps * -0.5; end
code[a_, b_, eps_] := N[(eps * -0.5), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot -0.5
\end{array}
Initial program 6.3%
*-commutative6.3%
times-frac6.3%
+-commutative6.3%
expm1-def17.9%
*-commutative17.9%
expm1-def18.5%
+-commutative18.5%
*-commutative18.5%
expm1-def53.3%
*-commutative53.3%
Simplified53.3%
Taylor expanded in eps around 0 54.7%
Taylor expanded in b around 0 95.1%
Taylor expanded in eps around inf 2.9%
*-commutative2.9%
Simplified2.9%
Final simplification2.9%
(FPCore (a b eps) :precision binary64 (/ 1.0 a))
double code(double a, double b, double eps) {
return 1.0 / a;
}
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
public static double code(double a, double b, double eps) {
return 1.0 / a;
}
def code(a, b, eps): return 1.0 / a
function code(a, b, eps) return Float64(1.0 / a) end
function tmp = code(a, b, eps) tmp = 1.0 / a; end
code[a_, b_, eps_] := N[(1.0 / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{a}
\end{array}
Initial program 6.3%
*-commutative6.3%
associate-*l/6.3%
*-commutative6.3%
expm1-def7.9%
*-commutative7.9%
associate-/r*7.9%
expm1-def18.5%
*-commutative18.5%
expm1-def47.7%
*-commutative47.7%
Simplified47.7%
Taylor expanded in a around 0 49.3%
Final simplification49.3%
(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 2023274
(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))))