
(FPCore (a b) :precision binary64 (log (+ (exp a) (exp b))))
double code(double a, double b) {
return log((exp(a) + exp(b)));
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = log((exp(a) + exp(b)))
end function
public static double code(double a, double b) {
return Math.log((Math.exp(a) + Math.exp(b)));
}
def code(a, b): return math.log((math.exp(a) + math.exp(b)))
function code(a, b) return log(Float64(exp(a) + exp(b))) end
function tmp = code(a, b) tmp = log((exp(a) + exp(b))); end
code[a_, b_] := N[Log[N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(e^{a} + e^{b}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b) :precision binary64 (log (+ (exp a) (exp b))))
double code(double a, double b) {
return log((exp(a) + exp(b)));
}
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = log((exp(a) + exp(b)))
end function
public static double code(double a, double b) {
return Math.log((Math.exp(a) + Math.exp(b)));
}
def code(a, b): return math.log((math.exp(a) + math.exp(b)))
function code(a, b) return log(Float64(exp(a) + exp(b))) end
function tmp = code(a, b) tmp = log((exp(a) + exp(b))); end
code[a_, b_] := N[Log[N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(e^{a} + e^{b}\right)
\end{array}
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (+ (log1p (exp (- a b))) b))
assert(a < b);
double code(double a, double b) {
return log1p(exp((a - b))) + b;
}
assert a < b;
public static double code(double a, double b) {
return Math.log1p(Math.exp((a - b))) + b;
}
[a, b] = sort([a, b]) def code(a, b): return math.log1p(math.exp((a - b))) + b
a, b = sort([a, b]) function code(a, b) return Float64(log1p(exp(Float64(a - b))) + b) end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := N[(N[Log[1 + N[Exp[N[(a - b), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\mathsf{log1p}\left(e^{a - b}\right) + b
\end{array}
Initial program 53.4%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites48.9%
lift-log.f64N/A
lift-/.f64N/A
lift-exp.f64N/A
lift-+.f64N/A
exp-sumN/A
lift-exp.f64N/A
*-rgt-identityN/A
lift-*.f64N/A
lift-exp.f64N/A
*-lft-identityN/A
associate-/r*N/A
log-divN/A
*-lft-identityN/A
lift-exp.f64N/A
Applied rewrites72.3%
Taylor expanded in a around inf
+-commutativeN/A
lower-+.f64N/A
lower-log1p.f64N/A
lower-exp.f64N/A
lower--.f6472.3
Applied rewrites72.3%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -160.0) (* 0.5 b) (+ (log1p (exp (- b))) b)))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -160.0) {
tmp = 0.5 * b;
} else {
tmp = log1p(exp(-b)) + b;
}
return tmp;
}
assert a < b;
public static double code(double a, double b) {
double tmp;
if (a <= -160.0) {
tmp = 0.5 * b;
} else {
tmp = Math.log1p(Math.exp(-b)) + b;
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b): tmp = 0 if a <= -160.0: tmp = 0.5 * b else: tmp = math.log1p(math.exp(-b)) + b return tmp
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -160.0) tmp = Float64(0.5 * b); else tmp = Float64(log1p(exp(Float64(-b))) + b); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -160.0], N[(0.5 * b), $MachinePrecision], N[(N[Log[1 + N[Exp[(-b)], $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -160:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(e^{-b}\right) + b\\
\end{array}
\end{array}
if a < -160Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -160 < a Initial program 67.0%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites62.8%
lift-log.f64N/A
lift-/.f64N/A
lift-exp.f64N/A
lift-+.f64N/A
exp-sumN/A
lift-exp.f64N/A
*-rgt-identityN/A
lift-*.f64N/A
lift-exp.f64N/A
*-lft-identityN/A
associate-/r*N/A
log-divN/A
*-lft-identityN/A
lift-exp.f64N/A
Applied rewrites64.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-+.f64N/A
lower-log1p.f64N/A
lower-exp.f64N/A
lower-neg.f6462.6
Applied rewrites62.6%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -360.0) (* 0.5 b) (log1p (exp a))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -360.0) {
tmp = 0.5 * b;
} else {
tmp = log1p(exp(a));
}
return tmp;
}
assert a < b;
public static double code(double a, double b) {
double tmp;
if (a <= -360.0) {
tmp = 0.5 * b;
} else {
tmp = Math.log1p(Math.exp(a));
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b): tmp = 0 if a <= -360.0: tmp = 0.5 * b else: tmp = math.log1p(math.exp(a)) return tmp
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -360.0) tmp = Float64(0.5 * b); else tmp = log1p(exp(a)); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -360.0], N[(0.5 * b), $MachinePrecision], N[Log[1 + N[Exp[a], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -360:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(e^{a}\right)\\
\end{array}
\end{array}
if a < -360Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -360 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Final simplification53.8%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -132.0) (* 0.5 b) (fma (fma 0.125 a (fma -0.25 b 0.5)) a (fma 0.5 b (log 2.0)))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -132.0) {
tmp = 0.5 * b;
} else {
tmp = fma(fma(0.125, a, fma(-0.25, b, 0.5)), a, fma(0.5, b, log(2.0)));
}
return tmp;
}
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -132.0) tmp = Float64(0.5 * b); else tmp = fma(fma(0.125, a, fma(-0.25, b, 0.5)), a, fma(0.5, b, log(2.0))); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -132.0], N[(0.5 * b), $MachinePrecision], N[(N[(0.125 * a + N[(-0.25 * b + 0.5), $MachinePrecision]), $MachinePrecision] * a + N[(0.5 * b + N[Log[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -132:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.125, a, \mathsf{fma}\left(-0.25, b, 0.5\right)\right), a, \mathsf{fma}\left(0.5, b, \log 2\right)\right)\\
\end{array}
\end{array}
if a < -132Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -132 < a Initial program 67.0%
Taylor expanded in b around 0
*-rgt-identityN/A
associate-*r/N/A
+-commutativeN/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-exp.f64N/A
lower-log1p.f64N/A
lower-exp.f6463.7
Applied rewrites63.7%
Taylor expanded in a around 0
Applied rewrites63.1%
Final simplification53.2%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -2.6) (* 0.5 b) (fma (fma (fma (* a a) -0.005208333333333333 0.125) a 0.5) a (log 2.0))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -2.6) {
tmp = 0.5 * b;
} else {
tmp = fma(fma(fma((a * a), -0.005208333333333333, 0.125), a, 0.5), a, log(2.0));
}
return tmp;
}
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -2.6) tmp = Float64(0.5 * b); else tmp = fma(fma(fma(Float64(a * a), -0.005208333333333333, 0.125), a, 0.5), a, log(2.0)); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -2.6], N[(0.5 * b), $MachinePrecision], N[(N[(N[(N[(a * a), $MachinePrecision] * -0.005208333333333333 + 0.125), $MachinePrecision] * a + 0.5), $MachinePrecision] * a + N[Log[2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.6:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(a \cdot a, -0.005208333333333333, 0.125\right), a, 0.5\right), a, \log 2\right)\\
\end{array}
\end{array}
if a < -2.60000000000000009Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -2.60000000000000009 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Taylor expanded in a around 0
Applied rewrites63.2%
Final simplification53.3%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -132.0) (* 0.5 b) (log (+ (fma (fma 0.5 a 1.0) a 1.0) (+ 1.0 b)))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -132.0) {
tmp = 0.5 * b;
} else {
tmp = log((fma(fma(0.5, a, 1.0), a, 1.0) + (1.0 + b)));
}
return tmp;
}
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -132.0) tmp = Float64(0.5 * b); else tmp = log(Float64(fma(fma(0.5, a, 1.0), a, 1.0) + Float64(1.0 + b))); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -132.0], N[(0.5 * b), $MachinePrecision], N[Log[N[(N[(N[(0.5 * a + 1.0), $MachinePrecision] * a + 1.0), $MachinePrecision] + N[(1.0 + b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -132:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\log \left(\mathsf{fma}\left(\mathsf{fma}\left(0.5, a, 1\right), a, 1\right) + \left(1 + b\right)\right)\\
\end{array}
\end{array}
if a < -132Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -132 < a Initial program 67.0%
Taylor expanded in a around 0
Applied rewrites62.8%
Taylor expanded in b around 0
lower-+.f6460.9
Applied rewrites60.9%
Taylor expanded in a around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6461.9
Applied rewrites61.9%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -132.0) (* 0.5 b) (fma (fma 0.125 a 0.5) a (log 2.0))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -132.0) {
tmp = 0.5 * b;
} else {
tmp = fma(fma(0.125, a, 0.5), a, log(2.0));
}
return tmp;
}
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -132.0) tmp = Float64(0.5 * b); else tmp = fma(fma(0.125, a, 0.5), a, log(2.0)); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -132.0], N[(0.5 * b), $MachinePrecision], N[(N[(0.125 * a + 0.5), $MachinePrecision] * a + N[Log[2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -132:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.125, a, 0.5\right), a, \log 2\right)\\
\end{array}
\end{array}
if a < -132Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -132 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Taylor expanded in a around 0
Applied rewrites63.2%
Final simplification53.3%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -1.0) (* 0.5 b) (log (+ (+ 1.0 a) (+ 1.0 b)))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -1.0) {
tmp = 0.5 * b;
} else {
tmp = log(((1.0 + a) + (1.0 + b)));
}
return tmp;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= (-1.0d0)) then
tmp = 0.5d0 * b
else
tmp = log(((1.0d0 + a) + (1.0d0 + b)))
end if
code = tmp
end function
assert a < b;
public static double code(double a, double b) {
double tmp;
if (a <= -1.0) {
tmp = 0.5 * b;
} else {
tmp = Math.log(((1.0 + a) + (1.0 + b)));
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b): tmp = 0 if a <= -1.0: tmp = 0.5 * b else: tmp = math.log(((1.0 + a) + (1.0 + b))) return tmp
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -1.0) tmp = Float64(0.5 * b); else tmp = log(Float64(Float64(1.0 + a) + Float64(1.0 + b))); end return tmp end
a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b)
tmp = 0.0;
if (a <= -1.0)
tmp = 0.5 * b;
else
tmp = log(((1.0 + a) + (1.0 + b)));
end
tmp_2 = tmp;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -1.0], N[(0.5 * b), $MachinePrecision], N[Log[N[(N[(1.0 + a), $MachinePrecision] + N[(1.0 + b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\log \left(\left(1 + a\right) + \left(1 + b\right)\right)\\
\end{array}
\end{array}
if a < -1Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -1 < a Initial program 67.0%
Taylor expanded in a around 0
Applied rewrites62.8%
Taylor expanded in b around 0
lower-+.f6460.9
Applied rewrites60.9%
Taylor expanded in a around 0
lower-+.f6461.5
Applied rewrites61.5%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -1.36) (* 0.5 b) (fma 0.5 a (log 2.0))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -1.36) {
tmp = 0.5 * b;
} else {
tmp = fma(0.5, a, log(2.0));
}
return tmp;
}
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -1.36) tmp = Float64(0.5 * b); else tmp = fma(0.5, a, log(2.0)); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -1.36], N[(0.5 * b), $MachinePrecision], N[(0.5 * a + N[Log[2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.36:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(0.5, a, \log 2\right)\\
\end{array}
\end{array}
if a < -1.3600000000000001Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -1.3600000000000001 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Taylor expanded in a around 0
Applied rewrites62.8%
Final simplification53.0%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -1.0) (* 0.5 b) (log1p (+ 1.0 a))))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -1.0) {
tmp = 0.5 * b;
} else {
tmp = log1p((1.0 + a));
}
return tmp;
}
assert a < b;
public static double code(double a, double b) {
double tmp;
if (a <= -1.0) {
tmp = 0.5 * b;
} else {
tmp = Math.log1p((1.0 + a));
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b): tmp = 0 if a <= -1.0: tmp = 0.5 * b else: tmp = math.log1p((1.0 + a)) return tmp
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -1.0) tmp = Float64(0.5 * b); else tmp = log1p(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_] := If[LessEqual[a, -1.0], N[(0.5 * b), $MachinePrecision], N[Log[1 + N[(1.0 + a), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(1 + a\right)\\
\end{array}
\end{array}
if a < -1Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -1 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Taylor expanded in a around 0
Applied rewrites62.7%
Final simplification52.9%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (if (<= a -132.0) (* 0.5 b) (log1p 1.0)))
assert(a < b);
double code(double a, double b) {
double tmp;
if (a <= -132.0) {
tmp = 0.5 * b;
} else {
tmp = log1p(1.0);
}
return tmp;
}
assert a < b;
public static double code(double a, double b) {
double tmp;
if (a <= -132.0) {
tmp = 0.5 * b;
} else {
tmp = Math.log1p(1.0);
}
return tmp;
}
[a, b] = sort([a, b]) def code(a, b): tmp = 0 if a <= -132.0: tmp = 0.5 * b else: tmp = math.log1p(1.0) return tmp
a, b = sort([a, b]) function code(a, b) tmp = 0.0 if (a <= -132.0) tmp = Float64(0.5 * b); else tmp = log1p(1.0); end return tmp end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := If[LessEqual[a, -132.0], N[(0.5 * b), $MachinePrecision], N[Log[1 + 1.0], $MachinePrecision]]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -132:\\
\;\;\;\;0.5 \cdot b\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(1\right)\\
\end{array}
\end{array}
if a < -132Initial program 5.9%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites0.1%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f643.8
Applied rewrites3.8%
Taylor expanded in b around 0
Applied rewrites3.8%
Taylor expanded in b around inf
Applied rewrites18.8%
if -132 < a Initial program 67.0%
Taylor expanded in b around 0
lower-log1p.f64N/A
lower-exp.f6463.8
Applied rewrites63.8%
Taylor expanded in a around 0
Applied rewrites62.2%
Final simplification52.5%
NOTE: a and b should be sorted in increasing order before calling this function. (FPCore (a b) :precision binary64 (* 0.5 b))
assert(a < b);
double code(double a, double b) {
return 0.5 * b;
}
NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b)
real(8), intent (in) :: a
real(8), intent (in) :: b
code = 0.5d0 * b
end function
assert a < b;
public static double code(double a, double b) {
return 0.5 * b;
}
[a, b] = sort([a, b]) def code(a, b): return 0.5 * b
a, b = sort([a, b]) function code(a, b) return Float64(0.5 * b) end
a, b = num2cell(sort([a, b])){:}
function tmp = code(a, b)
tmp = 0.5 * b;
end
NOTE: a and b should be sorted in increasing order before calling this function. code[a_, b_] := N[(0.5 * b), $MachinePrecision]
\begin{array}{l}
[a, b] = \mathsf{sort}([a, b])\\
\\
0.5 \cdot b
\end{array}
Initial program 53.4%
lift-+.f64N/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh-coshN/A
sinh-coshN/A
sinh---cosh-revN/A
lift-exp.f64N/A
sinh-+-cosh-revN/A
flip-+N/A
sinh---cosh-revN/A
frac-addN/A
lower-/.f64N/A
Applied rewrites48.9%
Taylor expanded in a around 0
div-addN/A
*-inversesN/A
+-commutativeN/A
lower-log1p.f64N/A
exp-negN/A
remove-double-divN/A
lower-exp.f6450.1
Applied rewrites50.1%
Taylor expanded in b around 0
Applied rewrites48.9%
Taylor expanded in b around inf
Applied rewrites6.8%
herbie shell --seed 2024343
(FPCore (a b)
:name "symmetry log of sum of exp"
:precision binary64
(log (+ (exp a) (exp b))))