
(FPCore (c_p c_n t s)
:precision binary64
(let* ((t_1 (/ 1.0 (+ 1.0 (exp (- t))))) (t_2 (/ 1.0 (+ 1.0 (exp (- s))))))
(/
(* (pow t_2 c_p) (pow (- 1.0 t_2) c_n))
(* (pow t_1 c_p) (pow (- 1.0 t_1) c_n)))))
double code(double c_p, double c_n, double t, double s) {
double t_1 = 1.0 / (1.0 + exp(-t));
double t_2 = 1.0 / (1.0 + exp(-s));
return (pow(t_2, c_p) * pow((1.0 - t_2), c_n)) / (pow(t_1, c_p) * pow((1.0 - t_1), c_n));
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
real(8) :: t_1
real(8) :: t_2
t_1 = 1.0d0 / (1.0d0 + exp(-t))
t_2 = 1.0d0 / (1.0d0 + exp(-s))
code = ((t_2 ** c_p) * ((1.0d0 - t_2) ** c_n)) / ((t_1 ** c_p) * ((1.0d0 - t_1) ** c_n))
end function
public static double code(double c_p, double c_n, double t, double s) {
double t_1 = 1.0 / (1.0 + Math.exp(-t));
double t_2 = 1.0 / (1.0 + Math.exp(-s));
return (Math.pow(t_2, c_p) * Math.pow((1.0 - t_2), c_n)) / (Math.pow(t_1, c_p) * Math.pow((1.0 - t_1), c_n));
}
def code(c_p, c_n, t, s): t_1 = 1.0 / (1.0 + math.exp(-t)) t_2 = 1.0 / (1.0 + math.exp(-s)) return (math.pow(t_2, c_p) * math.pow((1.0 - t_2), c_n)) / (math.pow(t_1, c_p) * math.pow((1.0 - t_1), c_n))
function code(c_p, c_n, t, s) t_1 = Float64(1.0 / Float64(1.0 + exp(Float64(-t)))) t_2 = Float64(1.0 / Float64(1.0 + exp(Float64(-s)))) return Float64(Float64((t_2 ^ c_p) * (Float64(1.0 - t_2) ^ c_n)) / Float64((t_1 ^ c_p) * (Float64(1.0 - t_1) ^ c_n))) end
function tmp = code(c_p, c_n, t, s) t_1 = 1.0 / (1.0 + exp(-t)); t_2 = 1.0 / (1.0 + exp(-s)); tmp = ((t_2 ^ c_p) * ((1.0 - t_2) ^ c_n)) / ((t_1 ^ c_p) * ((1.0 - t_1) ^ c_n)); end
code[c$95$p_, c$95$n_, t_, s_] := Block[{t$95$1 = N[(1.0 / N[(1.0 + N[Exp[(-t)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(1.0 / N[(1.0 + N[Exp[(-s)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Power[t$95$2, c$95$p], $MachinePrecision] * N[Power[N[(1.0 - t$95$2), $MachinePrecision], c$95$n], $MachinePrecision]), $MachinePrecision] / N[(N[Power[t$95$1, c$95$p], $MachinePrecision] * N[Power[N[(1.0 - t$95$1), $MachinePrecision], c$95$n], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{1}{1 + e^{-t}}\\
t_2 := \frac{1}{1 + e^{-s}}\\
\frac{{t\_2}^{c\_p} \cdot {\left(1 - t\_2\right)}^{c\_n}}{{t\_1}^{c\_p} \cdot {\left(1 - t\_1\right)}^{c\_n}}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (c_p c_n t s)
:precision binary64
(let* ((t_1 (/ 1.0 (+ 1.0 (exp (- t))))) (t_2 (/ 1.0 (+ 1.0 (exp (- s))))))
(/
(* (pow t_2 c_p) (pow (- 1.0 t_2) c_n))
(* (pow t_1 c_p) (pow (- 1.0 t_1) c_n)))))
double code(double c_p, double c_n, double t, double s) {
double t_1 = 1.0 / (1.0 + exp(-t));
double t_2 = 1.0 / (1.0 + exp(-s));
return (pow(t_2, c_p) * pow((1.0 - t_2), c_n)) / (pow(t_1, c_p) * pow((1.0 - t_1), c_n));
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
real(8) :: t_1
real(8) :: t_2
t_1 = 1.0d0 / (1.0d0 + exp(-t))
t_2 = 1.0d0 / (1.0d0 + exp(-s))
code = ((t_2 ** c_p) * ((1.0d0 - t_2) ** c_n)) / ((t_1 ** c_p) * ((1.0d0 - t_1) ** c_n))
end function
public static double code(double c_p, double c_n, double t, double s) {
double t_1 = 1.0 / (1.0 + Math.exp(-t));
double t_2 = 1.0 / (1.0 + Math.exp(-s));
return (Math.pow(t_2, c_p) * Math.pow((1.0 - t_2), c_n)) / (Math.pow(t_1, c_p) * Math.pow((1.0 - t_1), c_n));
}
def code(c_p, c_n, t, s): t_1 = 1.0 / (1.0 + math.exp(-t)) t_2 = 1.0 / (1.0 + math.exp(-s)) return (math.pow(t_2, c_p) * math.pow((1.0 - t_2), c_n)) / (math.pow(t_1, c_p) * math.pow((1.0 - t_1), c_n))
function code(c_p, c_n, t, s) t_1 = Float64(1.0 / Float64(1.0 + exp(Float64(-t)))) t_2 = Float64(1.0 / Float64(1.0 + exp(Float64(-s)))) return Float64(Float64((t_2 ^ c_p) * (Float64(1.0 - t_2) ^ c_n)) / Float64((t_1 ^ c_p) * (Float64(1.0 - t_1) ^ c_n))) end
function tmp = code(c_p, c_n, t, s) t_1 = 1.0 / (1.0 + exp(-t)); t_2 = 1.0 / (1.0 + exp(-s)); tmp = ((t_2 ^ c_p) * ((1.0 - t_2) ^ c_n)) / ((t_1 ^ c_p) * ((1.0 - t_1) ^ c_n)); end
code[c$95$p_, c$95$n_, t_, s_] := Block[{t$95$1 = N[(1.0 / N[(1.0 + N[Exp[(-t)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(1.0 / N[(1.0 + N[Exp[(-s)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Power[t$95$2, c$95$p], $MachinePrecision] * N[Power[N[(1.0 - t$95$2), $MachinePrecision], c$95$n], $MachinePrecision]), $MachinePrecision] / N[(N[Power[t$95$1, c$95$p], $MachinePrecision] * N[Power[N[(1.0 - t$95$1), $MachinePrecision], c$95$n], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{1}{1 + e^{-t}}\\
t_2 := \frac{1}{1 + e^{-s}}\\
\frac{{t\_2}^{c\_p} \cdot {\left(1 - t\_2\right)}^{c\_n}}{{t\_1}^{c\_p} \cdot {\left(1 - t\_1\right)}^{c\_n}}
\end{array}
\end{array}
(FPCore (c_p c_n t s)
:precision binary64
(if (<= c_p 5e-30)
(pow
(sqrt
(exp
(+
(-
(- (* c_n (log1p (/ 1.0 (+ (exp s) 1.0)))) (* c_p (log1p (exp s))))
(* c_n (log1p (/ 1.0 (+ 1.0 (exp t))))))
(* c_p (log1p (exp t))))))
2.0)
(exp (* c_p (- (log1p (exp (- t))) (log1p (exp (- s))))))))
double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 5e-30) {
tmp = pow(sqrt(exp(((((c_n * log1p((1.0 / (exp(s) + 1.0)))) - (c_p * log1p(exp(s)))) - (c_n * log1p((1.0 / (1.0 + exp(t)))))) + (c_p * log1p(exp(t)))))), 2.0);
} else {
tmp = exp((c_p * (log1p(exp(-t)) - log1p(exp(-s)))));
}
return tmp;
}
public static double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 5e-30) {
tmp = Math.pow(Math.sqrt(Math.exp(((((c_n * Math.log1p((1.0 / (Math.exp(s) + 1.0)))) - (c_p * Math.log1p(Math.exp(s)))) - (c_n * Math.log1p((1.0 / (1.0 + Math.exp(t)))))) + (c_p * Math.log1p(Math.exp(t)))))), 2.0);
} else {
tmp = Math.exp((c_p * (Math.log1p(Math.exp(-t)) - Math.log1p(Math.exp(-s)))));
}
return tmp;
}
def code(c_p, c_n, t, s): tmp = 0 if c_p <= 5e-30: tmp = math.pow(math.sqrt(math.exp(((((c_n * math.log1p((1.0 / (math.exp(s) + 1.0)))) - (c_p * math.log1p(math.exp(s)))) - (c_n * math.log1p((1.0 / (1.0 + math.exp(t)))))) + (c_p * math.log1p(math.exp(t)))))), 2.0) else: tmp = math.exp((c_p * (math.log1p(math.exp(-t)) - math.log1p(math.exp(-s))))) return tmp
function code(c_p, c_n, t, s) tmp = 0.0 if (c_p <= 5e-30) tmp = sqrt(exp(Float64(Float64(Float64(Float64(c_n * log1p(Float64(1.0 / Float64(exp(s) + 1.0)))) - Float64(c_p * log1p(exp(s)))) - Float64(c_n * log1p(Float64(1.0 / Float64(1.0 + exp(t)))))) + Float64(c_p * log1p(exp(t)))))) ^ 2.0; else tmp = exp(Float64(c_p * Float64(log1p(exp(Float64(-t))) - log1p(exp(Float64(-s)))))); end return tmp end
code[c$95$p_, c$95$n_, t_, s_] := If[LessEqual[c$95$p, 5e-30], N[Power[N[Sqrt[N[Exp[N[(N[(N[(N[(c$95$n * N[Log[1 + N[(1.0 / N[(N[Exp[s], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(c$95$p * N[Log[1 + N[Exp[s], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c$95$n * N[Log[1 + N[(1.0 / N[(1.0 + N[Exp[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c$95$p * N[Log[1 + N[Exp[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], 2.0], $MachinePrecision], N[Exp[N[(c$95$p * N[(N[Log[1 + N[Exp[(-t)], $MachinePrecision]], $MachinePrecision] - N[Log[1 + N[Exp[(-s)], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c\_p \leq 5 \cdot 10^{-30}:\\
\;\;\;\;{\left(\sqrt{e^{\left(\left(c\_n \cdot \mathsf{log1p}\left(\frac{1}{e^{s} + 1}\right) - c\_p \cdot \mathsf{log1p}\left(e^{s}\right)\right) - c\_n \cdot \mathsf{log1p}\left(\frac{1}{1 + e^{t}}\right)\right) + c\_p \cdot \mathsf{log1p}\left(e^{t}\right)}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;e^{c\_p \cdot \left(\mathsf{log1p}\left(e^{-t}\right) - \mathsf{log1p}\left(e^{-s}\right)\right)}\\
\end{array}
\end{array}
if c_p < 4.99999999999999972e-30Initial program 90.9%
associate-/l/90.9%
Simplified90.9%
Applied egg-rr99.2%
if 4.99999999999999972e-30 < c_p Initial program 57.9%
associate-/l/57.9%
Simplified57.9%
Taylor expanded in c_n around 0 65.7%
add-exp-log65.7%
log-div65.7%
log-pow69.0%
log-rec69.0%
log1p-define69.0%
log-pow99.4%
neg-log99.4%
log1p-define99.4%
Applied egg-rr99.4%
log1p-undefine99.4%
log-rec99.4%
distribute-lft-out--99.4%
log-rec99.4%
log1p-undefine99.4%
Simplified99.4%
Final simplification99.2%
(FPCore (c_p c_n t s) :precision binary64 (if (<= c_p 3e-29) (pow (/ 2.0 (+ (exp s) 1.0)) c_p) (exp (* c_p (- (log1p (exp (- t))) (log1p (exp (- s))))))))
double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 3e-29) {
tmp = pow((2.0 / (exp(s) + 1.0)), c_p);
} else {
tmp = exp((c_p * (log1p(exp(-t)) - log1p(exp(-s)))));
}
return tmp;
}
public static double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 3e-29) {
tmp = Math.pow((2.0 / (Math.exp(s) + 1.0)), c_p);
} else {
tmp = Math.exp((c_p * (Math.log1p(Math.exp(-t)) - Math.log1p(Math.exp(-s)))));
}
return tmp;
}
def code(c_p, c_n, t, s): tmp = 0 if c_p <= 3e-29: tmp = math.pow((2.0 / (math.exp(s) + 1.0)), c_p) else: tmp = math.exp((c_p * (math.log1p(math.exp(-t)) - math.log1p(math.exp(-s))))) return tmp
function code(c_p, c_n, t, s) tmp = 0.0 if (c_p <= 3e-29) tmp = Float64(2.0 / Float64(exp(s) + 1.0)) ^ c_p; else tmp = exp(Float64(c_p * Float64(log1p(exp(Float64(-t))) - log1p(exp(Float64(-s)))))); end return tmp end
code[c$95$p_, c$95$n_, t_, s_] := If[LessEqual[c$95$p, 3e-29], N[Power[N[(2.0 / N[(N[Exp[s], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], c$95$p], $MachinePrecision], N[Exp[N[(c$95$p * N[(N[Log[1 + N[Exp[(-t)], $MachinePrecision]], $MachinePrecision] - N[Log[1 + N[Exp[(-s)], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c\_p \leq 3 \cdot 10^{-29}:\\
\;\;\;\;{\left(\frac{2}{e^{s} + 1}\right)}^{c\_p}\\
\mathbf{else}:\\
\;\;\;\;e^{c\_p \cdot \left(\mathsf{log1p}\left(e^{-t}\right) - \mathsf{log1p}\left(e^{-s}\right)\right)}\\
\end{array}
\end{array}
if c_p < 3.0000000000000003e-29Initial program 90.9%
associate-/l/90.9%
Simplified90.9%
Taylor expanded in c_n around 0 93.8%
add-exp-log93.8%
log-div93.8%
log-pow93.8%
log-rec93.8%
log1p-define93.8%
log-pow93.8%
neg-log93.8%
log1p-define93.8%
Applied egg-rr93.8%
log1p-undefine93.8%
log-rec93.8%
distribute-lft-out--93.8%
log-rec93.8%
log1p-undefine93.8%
Simplified93.8%
Taylor expanded in t around 0 94.7%
log1p-define94.7%
Simplified94.7%
*-commutative94.7%
exp-prod94.7%
exp-diff94.7%
log1p-undefine94.7%
add-exp-log94.7%
rem-exp-log94.7%
+-commutative94.7%
add-sqr-sqrt47.9%
sqrt-unprod97.4%
sqr-neg97.4%
sqrt-unprod49.5%
add-sqr-sqrt98.3%
Applied egg-rr98.3%
if 3.0000000000000003e-29 < c_p Initial program 57.9%
associate-/l/57.9%
Simplified57.9%
Taylor expanded in c_n around 0 65.7%
add-exp-log65.7%
log-div65.7%
log-pow69.0%
log-rec69.0%
log1p-define69.0%
log-pow99.4%
neg-log99.4%
log1p-define99.4%
Applied egg-rr99.4%
log1p-undefine99.4%
log-rec99.4%
distribute-lft-out--99.4%
log-rec99.4%
log1p-undefine99.4%
Simplified99.4%
Final simplification98.5%
(FPCore (c_p c_n t s) :precision binary64 (if (<= c_p 2e-29) (pow (/ 2.0 (+ (exp s) 1.0)) c_p) (exp (* c_p (- (log 2.0) (log1p (exp (- s))))))))
double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 2e-29) {
tmp = pow((2.0 / (exp(s) + 1.0)), c_p);
} else {
tmp = exp((c_p * (log(2.0) - log1p(exp(-s)))));
}
return tmp;
}
public static double code(double c_p, double c_n, double t, double s) {
double tmp;
if (c_p <= 2e-29) {
tmp = Math.pow((2.0 / (Math.exp(s) + 1.0)), c_p);
} else {
tmp = Math.exp((c_p * (Math.log(2.0) - Math.log1p(Math.exp(-s)))));
}
return tmp;
}
def code(c_p, c_n, t, s): tmp = 0 if c_p <= 2e-29: tmp = math.pow((2.0 / (math.exp(s) + 1.0)), c_p) else: tmp = math.exp((c_p * (math.log(2.0) - math.log1p(math.exp(-s))))) return tmp
function code(c_p, c_n, t, s) tmp = 0.0 if (c_p <= 2e-29) tmp = Float64(2.0 / Float64(exp(s) + 1.0)) ^ c_p; else tmp = exp(Float64(c_p * Float64(log(2.0) - log1p(exp(Float64(-s)))))); end return tmp end
code[c$95$p_, c$95$n_, t_, s_] := If[LessEqual[c$95$p, 2e-29], N[Power[N[(2.0 / N[(N[Exp[s], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], c$95$p], $MachinePrecision], N[Exp[N[(c$95$p * N[(N[Log[2.0], $MachinePrecision] - N[Log[1 + N[Exp[(-s)], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c\_p \leq 2 \cdot 10^{-29}:\\
\;\;\;\;{\left(\frac{2}{e^{s} + 1}\right)}^{c\_p}\\
\mathbf{else}:\\
\;\;\;\;e^{c\_p \cdot \left(\log 2 - \mathsf{log1p}\left(e^{-s}\right)\right)}\\
\end{array}
\end{array}
if c_p < 1.99999999999999989e-29Initial program 90.9%
associate-/l/90.9%
Simplified90.9%
Taylor expanded in c_n around 0 93.8%
add-exp-log93.8%
log-div93.8%
log-pow93.8%
log-rec93.8%
log1p-define93.8%
log-pow93.8%
neg-log93.8%
log1p-define93.8%
Applied egg-rr93.8%
log1p-undefine93.8%
log-rec93.8%
distribute-lft-out--93.8%
log-rec93.8%
log1p-undefine93.8%
Simplified93.8%
Taylor expanded in t around 0 94.7%
log1p-define94.7%
Simplified94.7%
*-commutative94.7%
exp-prod94.7%
exp-diff94.7%
log1p-undefine94.7%
add-exp-log94.7%
rem-exp-log94.7%
+-commutative94.7%
add-sqr-sqrt47.9%
sqrt-unprod97.4%
sqr-neg97.4%
sqrt-unprod49.5%
add-sqr-sqrt98.3%
Applied egg-rr98.3%
if 1.99999999999999989e-29 < c_p Initial program 57.9%
associate-/l/57.9%
Simplified57.9%
Taylor expanded in c_n around 0 65.7%
add-exp-log65.7%
log-div65.7%
log-pow69.0%
log-rec69.0%
log1p-define69.0%
log-pow99.4%
neg-log99.4%
log1p-define99.4%
Applied egg-rr99.4%
log1p-undefine99.4%
log-rec99.4%
distribute-lft-out--99.4%
log-rec99.4%
log1p-undefine99.4%
Simplified99.4%
Taylor expanded in t around 0 96.8%
log1p-define96.8%
Simplified96.8%
(FPCore (c_p c_n t s) :precision binary64 (exp (* c_p (* s (+ 0.5 (* s -0.125))))))
double code(double c_p, double c_n, double t, double s) {
return exp((c_p * (s * (0.5 + (s * -0.125)))));
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
code = exp((c_p * (s * (0.5d0 + (s * (-0.125d0))))))
end function
public static double code(double c_p, double c_n, double t, double s) {
return Math.exp((c_p * (s * (0.5 + (s * -0.125)))));
}
def code(c_p, c_n, t, s): return math.exp((c_p * (s * (0.5 + (s * -0.125)))))
function code(c_p, c_n, t, s) return exp(Float64(c_p * Float64(s * Float64(0.5 + Float64(s * -0.125))))) end
function tmp = code(c_p, c_n, t, s) tmp = exp((c_p * (s * (0.5 + (s * -0.125))))); end
code[c$95$p_, c$95$n_, t_, s_] := N[Exp[N[(c$95$p * N[(s * N[(0.5 + N[(s * -0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{c\_p \cdot \left(s \cdot \left(0.5 + s \cdot -0.125\right)\right)}
\end{array}
Initial program 86.0%
associate-/l/86.0%
Simplified86.0%
Taylor expanded in c_n around 0 89.7%
add-exp-log89.7%
log-div89.7%
log-pow90.2%
log-rec90.2%
log1p-define90.2%
log-pow94.7%
neg-log94.7%
log1p-define94.7%
Applied egg-rr94.7%
log1p-undefine94.7%
log-rec94.7%
distribute-lft-out--94.7%
log-rec94.7%
log1p-undefine94.7%
Simplified94.7%
Taylor expanded in t around 0 95.1%
log1p-define95.1%
Simplified95.1%
Taylor expanded in s around 0 96.4%
*-commutative96.4%
Simplified96.4%
(FPCore (c_p c_n t s) :precision binary64 (exp (* c_p (* s 0.5))))
double code(double c_p, double c_n, double t, double s) {
return exp((c_p * (s * 0.5)));
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
code = exp((c_p * (s * 0.5d0)))
end function
public static double code(double c_p, double c_n, double t, double s) {
return Math.exp((c_p * (s * 0.5)));
}
def code(c_p, c_n, t, s): return math.exp((c_p * (s * 0.5)))
function code(c_p, c_n, t, s) return exp(Float64(c_p * Float64(s * 0.5))) end
function tmp = code(c_p, c_n, t, s) tmp = exp((c_p * (s * 0.5))); end
code[c$95$p_, c$95$n_, t_, s_] := N[Exp[N[(c$95$p * N[(s * 0.5), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{c\_p \cdot \left(s \cdot 0.5\right)}
\end{array}
Initial program 86.0%
associate-/l/86.0%
Simplified86.0%
Taylor expanded in c_n around 0 89.7%
add-exp-log89.7%
log-div89.7%
log-pow90.2%
log-rec90.2%
log1p-define90.2%
log-pow94.7%
neg-log94.7%
log1p-define94.7%
Applied egg-rr94.7%
log1p-undefine94.7%
log-rec94.7%
distribute-lft-out--94.7%
log-rec94.7%
log1p-undefine94.7%
Simplified94.7%
Taylor expanded in t around 0 95.1%
log1p-define95.1%
Simplified95.1%
Taylor expanded in s around 0 95.6%
*-commutative95.6%
associate-*l*95.6%
Simplified95.6%
(FPCore (c_p c_n t s) :precision binary64 (+ 1.0 (* -0.5 (* c_p t))))
double code(double c_p, double c_n, double t, double s) {
return 1.0 + (-0.5 * (c_p * t));
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
code = 1.0d0 + ((-0.5d0) * (c_p * t))
end function
public static double code(double c_p, double c_n, double t, double s) {
return 1.0 + (-0.5 * (c_p * t));
}
def code(c_p, c_n, t, s): return 1.0 + (-0.5 * (c_p * t))
function code(c_p, c_n, t, s) return Float64(1.0 + Float64(-0.5 * Float64(c_p * t))) end
function tmp = code(c_p, c_n, t, s) tmp = 1.0 + (-0.5 * (c_p * t)); end
code[c$95$p_, c$95$n_, t_, s_] := N[(1.0 + N[(-0.5 * N[(c$95$p * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + -0.5 \cdot \left(c\_p \cdot t\right)
\end{array}
Initial program 86.0%
associate-/l/86.0%
Simplified86.0%
Taylor expanded in c_n around 0 89.7%
Taylor expanded in s around 0 89.5%
Taylor expanded in t around 0 93.1%
(FPCore (c_p c_n t s) :precision binary64 1.0)
double code(double c_p, double c_n, double t, double s) {
return 1.0;
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
code = 1.0d0
end function
public static double code(double c_p, double c_n, double t, double s) {
return 1.0;
}
def code(c_p, c_n, t, s): return 1.0
function code(c_p, c_n, t, s) return 1.0 end
function tmp = code(c_p, c_n, t, s) tmp = 1.0; end
code[c$95$p_, c$95$n_, t_, s_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 86.0%
associate-/l/86.0%
Simplified86.0%
Taylor expanded in c_n around 0 89.7%
Taylor expanded in c_p around 0 93.0%
(FPCore (c_p c_n t s) :precision binary64 (* (pow (/ (+ 1.0 (exp (- t))) (+ 1.0 (exp (- s)))) c_p) (pow (/ (+ 1.0 (exp t)) (+ 1.0 (exp s))) c_n)))
double code(double c_p, double c_n, double t, double s) {
return pow(((1.0 + exp(-t)) / (1.0 + exp(-s))), c_p) * pow(((1.0 + exp(t)) / (1.0 + exp(s))), c_n);
}
real(8) function code(c_p, c_n, t, s)
real(8), intent (in) :: c_p
real(8), intent (in) :: c_n
real(8), intent (in) :: t
real(8), intent (in) :: s
code = (((1.0d0 + exp(-t)) / (1.0d0 + exp(-s))) ** c_p) * (((1.0d0 + exp(t)) / (1.0d0 + exp(s))) ** c_n)
end function
public static double code(double c_p, double c_n, double t, double s) {
return Math.pow(((1.0 + Math.exp(-t)) / (1.0 + Math.exp(-s))), c_p) * Math.pow(((1.0 + Math.exp(t)) / (1.0 + Math.exp(s))), c_n);
}
def code(c_p, c_n, t, s): return math.pow(((1.0 + math.exp(-t)) / (1.0 + math.exp(-s))), c_p) * math.pow(((1.0 + math.exp(t)) / (1.0 + math.exp(s))), c_n)
function code(c_p, c_n, t, s) return Float64((Float64(Float64(1.0 + exp(Float64(-t))) / Float64(1.0 + exp(Float64(-s)))) ^ c_p) * (Float64(Float64(1.0 + exp(t)) / Float64(1.0 + exp(s))) ^ c_n)) end
function tmp = code(c_p, c_n, t, s) tmp = (((1.0 + exp(-t)) / (1.0 + exp(-s))) ^ c_p) * (((1.0 + exp(t)) / (1.0 + exp(s))) ^ c_n); end
code[c$95$p_, c$95$n_, t_, s_] := N[(N[Power[N[(N[(1.0 + N[Exp[(-t)], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[Exp[(-s)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], c$95$p], $MachinePrecision] * N[Power[N[(N[(1.0 + N[Exp[t], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[Exp[s], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], c$95$n], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{\left(\frac{1 + e^{-t}}{1 + e^{-s}}\right)}^{c\_p} \cdot {\left(\frac{1 + e^{t}}{1 + e^{s}}\right)}^{c\_n}
\end{array}
herbie shell --seed 2024165
(FPCore (c_p c_n t s)
:name "Harley's example"
:precision binary64
:pre (and (< 0.0 c_p) (< 0.0 c_n))
:alt
(! :herbie-platform default (* (pow (/ (+ 1 (exp (- t))) (+ 1 (exp (- s)))) c_p) (pow (/ (+ 1 (exp t)) (+ 1 (exp s))) c_n)))
(/ (* (pow (/ 1.0 (+ 1.0 (exp (- s)))) c_p) (pow (- 1.0 (/ 1.0 (+ 1.0 (exp (- s))))) c_n)) (* (pow (/ 1.0 (+ 1.0 (exp (- t)))) c_p) (pow (- 1.0 (/ 1.0 (+ 1.0 (exp (- t))))) c_n))))