
(FPCore (w l) :precision binary64 (* (exp (- w)) (pow l (exp w))))
double code(double w, double l) {
return exp(-w) * pow(l, exp(w));
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = exp(-w) * (l ** exp(w))
end function
public static double code(double w, double l) {
return Math.exp(-w) * Math.pow(l, Math.exp(w));
}
def code(w, l): return math.exp(-w) * math.pow(l, math.exp(w))
function code(w, l) return Float64(exp(Float64(-w)) * (l ^ exp(w))) end
function tmp = code(w, l) tmp = exp(-w) * (l ^ exp(w)); end
code[w_, l_] := N[(N[Exp[(-w)], $MachinePrecision] * N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{-w} \cdot {\ell}^{\left(e^{w}\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (w l) :precision binary64 (* (exp (- w)) (pow l (exp w))))
double code(double w, double l) {
return exp(-w) * pow(l, exp(w));
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = exp(-w) * (l ** exp(w))
end function
public static double code(double w, double l) {
return Math.exp(-w) * Math.pow(l, Math.exp(w));
}
def code(w, l): return math.exp(-w) * math.pow(l, math.exp(w))
function code(w, l) return Float64(exp(Float64(-w)) * (l ^ exp(w))) end
function tmp = code(w, l) tmp = exp(-w) * (l ^ exp(w)); end
code[w_, l_] := N[(N[Exp[(-w)], $MachinePrecision] * N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{-w} \cdot {\ell}^{\left(e^{w}\right)}
\end{array}
(FPCore (w l) :precision binary64 (let* ((t_0 (cbrt (cbrt (exp w))))) (/ (/ (/ (pow l (exp w)) t_0) (pow t_0 2.0)) (pow (pow t_0 3.0) 2.0))))
double code(double w, double l) {
double t_0 = cbrt(cbrt(exp(w)));
return ((pow(l, exp(w)) / t_0) / pow(t_0, 2.0)) / pow(pow(t_0, 3.0), 2.0);
}
public static double code(double w, double l) {
double t_0 = Math.cbrt(Math.cbrt(Math.exp(w)));
return ((Math.pow(l, Math.exp(w)) / t_0) / Math.pow(t_0, 2.0)) / Math.pow(Math.pow(t_0, 3.0), 2.0);
}
function code(w, l) t_0 = cbrt(cbrt(exp(w))) return Float64(Float64(Float64((l ^ exp(w)) / t_0) / (t_0 ^ 2.0)) / ((t_0 ^ 3.0) ^ 2.0)) end
code[w_, l_] := Block[{t$95$0 = N[Power[N[Power[N[Exp[w], $MachinePrecision], 1/3], $MachinePrecision], 1/3], $MachinePrecision]}, N[(N[(N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[N[Power[t$95$0, 3.0], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt[3]{\sqrt[3]{e^{w}}}\\
\frac{\frac{\frac{{\ell}^{\left(e^{w}\right)}}{t_0}}{{t_0}^{2}}}{{\left({t_0}^{3}\right)}^{2}}
\end{array}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around inf 94.1%
mul-1-neg94.1%
distribute-rgt-neg-in94.1%
log-rec94.1%
remove-double-div94.1%
Simplified94.1%
*-un-lft-identity94.1%
metadata-eval94.1%
add-cube-cbrt94.1%
times-frac94.1%
metadata-eval94.1%
pow294.1%
*-commutative94.1%
exp-to-pow99.2%
Applied egg-rr99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
*-un-lft-identity99.2%
add-cube-cbrt99.2%
unpow299.2%
cbrt-prod99.2%
times-frac99.2%
unpow299.2%
cbrt-prod99.2%
pow299.2%
Applied egg-rr99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
add-cube-cbrt99.2%
pow399.2%
Applied egg-rr99.2%
Final simplification99.2%
(FPCore (w l) :precision binary64 (/ (* (pow l (exp w)) (exp (* w -0.3333333333333333))) (pow (pow (cbrt (cbrt (exp w))) 3.0) 2.0)))
double code(double w, double l) {
return (pow(l, exp(w)) * exp((w * -0.3333333333333333))) / pow(pow(cbrt(cbrt(exp(w))), 3.0), 2.0);
}
public static double code(double w, double l) {
return (Math.pow(l, Math.exp(w)) * Math.exp((w * -0.3333333333333333))) / Math.pow(Math.pow(Math.cbrt(Math.cbrt(Math.exp(w))), 3.0), 2.0);
}
function code(w, l) return Float64(Float64((l ^ exp(w)) * exp(Float64(w * -0.3333333333333333))) / ((cbrt(cbrt(exp(w))) ^ 3.0) ^ 2.0)) end
code[w_, l_] := N[(N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] * N[Exp[N[(w * -0.3333333333333333), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Power[N[Power[N[Power[N[Power[N[Exp[w], $MachinePrecision], 1/3], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\ell}^{\left(e^{w}\right)} \cdot e^{w \cdot -0.3333333333333333}}{{\left({\left(\sqrt[3]{\sqrt[3]{e^{w}}}\right)}^{3}\right)}^{2}}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around inf 94.1%
mul-1-neg94.1%
distribute-rgt-neg-in94.1%
log-rec94.1%
remove-double-div94.1%
Simplified94.1%
*-un-lft-identity94.1%
metadata-eval94.1%
add-cube-cbrt94.1%
times-frac94.1%
metadata-eval94.1%
pow294.1%
*-commutative94.1%
exp-to-pow99.2%
Applied egg-rr99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
add-exp-log94.1%
log-div94.1%
log-pow94.1%
pow1/394.1%
log-pow94.1%
add-log-exp94.1%
Applied egg-rr94.1%
sub-neg94.1%
exp-sum94.1%
*-commutative94.1%
exp-to-pow99.2%
*-commutative99.2%
distribute-rgt-neg-in99.2%
metadata-eval99.2%
Simplified99.2%
add-cube-cbrt99.2%
pow399.2%
Applied egg-rr99.2%
Final simplification99.2%
(FPCore (w l) :precision binary64 (let* ((t_0 (cbrt (exp w)))) (/ (/ (pow l (exp w)) t_0) (pow t_0 2.0))))
double code(double w, double l) {
double t_0 = cbrt(exp(w));
return (pow(l, exp(w)) / t_0) / pow(t_0, 2.0);
}
public static double code(double w, double l) {
double t_0 = Math.cbrt(Math.exp(w));
return (Math.pow(l, Math.exp(w)) / t_0) / Math.pow(t_0, 2.0);
}
function code(w, l) t_0 = cbrt(exp(w)) return Float64(Float64((l ^ exp(w)) / t_0) / (t_0 ^ 2.0)) end
code[w_, l_] := Block[{t$95$0 = N[Power[N[Exp[w], $MachinePrecision], 1/3], $MachinePrecision]}, N[(N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt[3]{e^{w}}\\
\frac{\frac{{\ell}^{\left(e^{w}\right)}}{t_0}}{{t_0}^{2}}
\end{array}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around inf 94.1%
mul-1-neg94.1%
distribute-rgt-neg-in94.1%
log-rec94.1%
remove-double-div94.1%
Simplified94.1%
*-un-lft-identity94.1%
metadata-eval94.1%
add-cube-cbrt94.1%
times-frac94.1%
metadata-eval94.1%
pow294.1%
*-commutative94.1%
exp-to-pow99.2%
Applied egg-rr99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (w l) :precision binary64 (/ (* (pow l (exp w)) (exp (* w -0.3333333333333333))) (pow (cbrt (exp w)) 2.0)))
double code(double w, double l) {
return (pow(l, exp(w)) * exp((w * -0.3333333333333333))) / pow(cbrt(exp(w)), 2.0);
}
public static double code(double w, double l) {
return (Math.pow(l, Math.exp(w)) * Math.exp((w * -0.3333333333333333))) / Math.pow(Math.cbrt(Math.exp(w)), 2.0);
}
function code(w, l) return Float64(Float64((l ^ exp(w)) * exp(Float64(w * -0.3333333333333333))) / (cbrt(exp(w)) ^ 2.0)) end
code[w_, l_] := N[(N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] * N[Exp[N[(w * -0.3333333333333333), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Power[N[Power[N[Exp[w], $MachinePrecision], 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\ell}^{\left(e^{w}\right)} \cdot e^{w \cdot -0.3333333333333333}}{{\left(\sqrt[3]{e^{w}}\right)}^{2}}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around inf 94.1%
mul-1-neg94.1%
distribute-rgt-neg-in94.1%
log-rec94.1%
remove-double-div94.1%
Simplified94.1%
*-un-lft-identity94.1%
metadata-eval94.1%
add-cube-cbrt94.1%
times-frac94.1%
metadata-eval94.1%
pow294.1%
*-commutative94.1%
exp-to-pow99.2%
Applied egg-rr99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
add-exp-log94.1%
log-div94.1%
log-pow94.1%
pow1/394.1%
log-pow94.1%
add-log-exp94.1%
Applied egg-rr94.1%
sub-neg94.1%
exp-sum94.1%
*-commutative94.1%
exp-to-pow99.2%
*-commutative99.2%
distribute-rgt-neg-in99.2%
metadata-eval99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (w l) :precision binary64 (/ (pow l (exp w)) (exp w)))
double code(double w, double l) {
return pow(l, exp(w)) / exp(w);
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = (l ** exp(w)) / exp(w)
end function
public static double code(double w, double l) {
return Math.pow(l, Math.exp(w)) / Math.exp(w);
}
def code(w, l): return math.pow(l, math.exp(w)) / math.exp(w)
function code(w, l) return Float64((l ^ exp(w)) / exp(w)) end
function tmp = code(w, l) tmp = (l ^ exp(w)) / exp(w); end
code[w_, l_] := N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] / N[Exp[w], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (w l) :precision binary64 (if (or (<= w -0.68) (not (<= w 650.0))) (exp (- w)) l))
double code(double w, double l) {
double tmp;
if ((w <= -0.68) || !(w <= 650.0)) {
tmp = exp(-w);
} else {
tmp = l;
}
return tmp;
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
real(8) :: tmp
if ((w <= (-0.68d0)) .or. (.not. (w <= 650.0d0))) then
tmp = exp(-w)
else
tmp = l
end if
code = tmp
end function
public static double code(double w, double l) {
double tmp;
if ((w <= -0.68) || !(w <= 650.0)) {
tmp = Math.exp(-w);
} else {
tmp = l;
}
return tmp;
}
def code(w, l): tmp = 0 if (w <= -0.68) or not (w <= 650.0): tmp = math.exp(-w) else: tmp = l return tmp
function code(w, l) tmp = 0.0 if ((w <= -0.68) || !(w <= 650.0)) tmp = exp(Float64(-w)); else tmp = l; end return tmp end
function tmp_2 = code(w, l) tmp = 0.0; if ((w <= -0.68) || ~((w <= 650.0))) tmp = exp(-w); else tmp = l; end tmp_2 = tmp; end
code[w_, l_] := If[Or[LessEqual[w, -0.68], N[Not[LessEqual[w, 650.0]], $MachinePrecision]], N[Exp[(-w)], $MachinePrecision], l]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;w \leq -0.68 \lor \neg \left(w \leq 650\right):\\
\;\;\;\;e^{-w}\\
\mathbf{else}:\\
\;\;\;\;\ell\\
\end{array}
\end{array}
if w < -0.680000000000000049 or 650 < w Initial program 98.9%
exp-neg98.9%
associate-*l/98.9%
*-lft-identity98.9%
Simplified98.9%
Taylor expanded in l around inf 98.9%
mul-1-neg98.9%
distribute-rgt-neg-in98.9%
log-rec98.9%
remove-double-div98.9%
Simplified98.9%
div-exp99.9%
fma-neg99.9%
Applied egg-rr99.9%
Taylor expanded in w around inf 98.1%
mul-1-neg98.1%
Simplified98.1%
if -0.680000000000000049 < w < 650Initial program 99.4%
exp-neg99.4%
associate-*l/99.4%
*-lft-identity99.4%
Simplified99.4%
Taylor expanded in w around 0 96.8%
Taylor expanded in w around 0 96.8%
Final simplification97.3%
(FPCore (w l) :precision binary64 (/ l (exp w)))
double code(double w, double l) {
return l / exp(w);
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = l / exp(w)
end function
public static double code(double w, double l) {
return l / Math.exp(w);
}
def code(w, l): return l / math.exp(w)
function code(w, l) return Float64(l / exp(w)) end
function tmp = code(w, l) tmp = l / exp(w); end
code[w_, l_] := N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\ell}{e^{w}}
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in w around 0 97.3%
Final simplification97.3%
(FPCore (w l) :precision binary64 (if (<= w -1.0) (* w (- l)) l))
double code(double w, double l) {
double tmp;
if (w <= -1.0) {
tmp = w * -l;
} else {
tmp = l;
}
return tmp;
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
real(8) :: tmp
if (w <= (-1.0d0)) then
tmp = w * -l
else
tmp = l
end if
code = tmp
end function
public static double code(double w, double l) {
double tmp;
if (w <= -1.0) {
tmp = w * -l;
} else {
tmp = l;
}
return tmp;
}
def code(w, l): tmp = 0 if w <= -1.0: tmp = w * -l else: tmp = l return tmp
function code(w, l) tmp = 0.0 if (w <= -1.0) tmp = Float64(w * Float64(-l)); else tmp = l; end return tmp end
function tmp_2 = code(w, l) tmp = 0.0; if (w <= -1.0) tmp = w * -l; else tmp = l; end tmp_2 = tmp; end
code[w_, l_] := If[LessEqual[w, -1.0], N[(w * (-l)), $MachinePrecision], l]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;w \leq -1:\\
\;\;\;\;w \cdot \left(-\ell\right)\\
\mathbf{else}:\\
\;\;\;\;\ell\\
\end{array}
\end{array}
if w < -1Initial program 100.0%
exp-neg100.0%
associate-*l/100.0%
*-lft-identity100.0%
Simplified100.0%
Taylor expanded in w around 0 100.0%
Taylor expanded in w around 0 24.6%
mul-1-neg24.6%
unsub-neg24.6%
Simplified24.6%
Taylor expanded in w around inf 24.6%
mul-1-neg24.6%
*-commutative24.6%
distribute-rgt-neg-in24.6%
Simplified24.6%
if -1 < w Initial program 99.0%
exp-neg99.0%
associate-*l/99.0%
*-lft-identity99.0%
Simplified99.0%
Taylor expanded in w around 0 96.5%
Taylor expanded in w around 0 76.9%
Final simplification64.3%
(FPCore (w l) :precision binary64 (* l (- 1.0 w)))
double code(double w, double l) {
return l * (1.0 - w);
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = l * (1.0d0 - w)
end function
public static double code(double w, double l) {
return l * (1.0 - w);
}
def code(w, l): return l * (1.0 - w)
function code(w, l) return Float64(l * Float64(1.0 - w)) end
function tmp = code(w, l) tmp = l * (1.0 - w); end
code[w_, l_] := N[(l * N[(1.0 - w), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\ell \cdot \left(1 - w\right)
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in w around 0 97.3%
Taylor expanded in w around 0 63.9%
mul-1-neg63.9%
unsub-neg63.9%
Simplified63.9%
Taylor expanded in l around 0 63.9%
Final simplification63.9%
(FPCore (w l) :precision binary64 l)
double code(double w, double l) {
return l;
}
real(8) function code(w, l)
real(8), intent (in) :: w
real(8), intent (in) :: l
code = l
end function
public static double code(double w, double l) {
return l;
}
def code(w, l): return l
function code(w, l) return l end
function tmp = code(w, l) tmp = l; end
code[w_, l_] := l
\begin{array}{l}
\\
\ell
\end{array}
Initial program 99.2%
exp-neg99.2%
associate-*l/99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in w around 0 97.3%
Taylor expanded in w around 0 59.2%
Final simplification59.2%
herbie shell --seed 2023300
(FPCore (w l)
:name "exp-w (used to crash)"
:precision binary64
(* (exp (- w)) (pow l (exp w))))