
(FPCore (x y) :precision binary64 (exp (* (* x y) y)))
double code(double x, double y) {
return exp(((x * y) * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp(((x * y) * y))
end function
public static double code(double x, double y) {
return Math.exp(((x * y) * y));
}
def code(x, y): return math.exp(((x * y) * y))
function code(x, y) return exp(Float64(Float64(x * y) * y)) end
function tmp = code(x, y) tmp = exp(((x * y) * y)); end
code[x_, y_] := N[Exp[N[(N[(x * y), $MachinePrecision] * y), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x \cdot y\right) \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (exp (* (* x y) y)))
double code(double x, double y) {
return exp(((x * y) * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp(((x * y) * y))
end function
public static double code(double x, double y) {
return Math.exp(((x * y) * y));
}
def code(x, y): return math.exp(((x * y) * y))
function code(x, y) return exp(Float64(Float64(x * y) * y)) end
function tmp = code(x, y) tmp = exp(((x * y) * y)); end
code[x_, y_] := N[Exp[N[(N[(x * y), $MachinePrecision] * y), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x \cdot y\right) \cdot y}
\end{array}
(FPCore (x y) :precision binary64 (* (exp (* x (* (pow y 2.0) 0.6666666666666666))) (pow (* (cbrt (exp 2.0)) (cbrt E)) (* x (* (* y y) 0.3333333333333333)))))
double code(double x, double y) {
return exp((x * (pow(y, 2.0) * 0.6666666666666666))) * pow((cbrt(exp(2.0)) * cbrt(((double) M_E))), (x * ((y * y) * 0.3333333333333333)));
}
public static double code(double x, double y) {
return Math.exp((x * (Math.pow(y, 2.0) * 0.6666666666666666))) * Math.pow((Math.cbrt(Math.exp(2.0)) * Math.cbrt(Math.E)), (x * ((y * y) * 0.3333333333333333)));
}
function code(x, y) return Float64(exp(Float64(x * Float64((y ^ 2.0) * 0.6666666666666666))) * (Float64(cbrt(exp(2.0)) * cbrt(exp(1))) ^ Float64(x * Float64(Float64(y * y) * 0.3333333333333333)))) end
code[x_, y_] := N[(N[Exp[N[(x * N[(N[Power[y, 2.0], $MachinePrecision] * 0.6666666666666666), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Power[N[(N[Power[N[Exp[2.0], $MachinePrecision], 1/3], $MachinePrecision] * N[Power[E, 1/3], $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y * y), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{x \cdot \left({y}^{2} \cdot 0.6666666666666666\right)} \cdot {\left(\sqrt[3]{e^{2}} \cdot \sqrt[3]{e}\right)}^{\left(x \cdot \left(\left(y \cdot y\right) \cdot 0.3333333333333333\right)\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod99.9%
add-log-exp99.9%
add-cube-cbrt99.9%
log-prod99.9%
unpow-prod-up99.9%
Applied egg-rr99.9%
associate-*r*99.9%
*-commutative99.9%
metadata-eval99.9%
*-commutative99.9%
associate-*l*99.9%
Simplified99.9%
unpow299.9%
Applied egg-rr99.9%
e-exp-199.9%
pow-exp99.9%
*-un-lft-identity99.9%
associate-*l*99.9%
Applied egg-rr99.9%
add-cube-cbrt99.9%
associate-*l*99.9%
cbrt-unprod100.0%
e-exp-1100.0%
e-exp-1100.0%
prod-exp100.0%
metadata-eval100.0%
Applied egg-rr100.0%
*-commutative100.0%
Simplified100.0%
(FPCore (x y) :precision binary64 (* (exp (cbrt (pow (* x (* (pow y 2.0) 0.6666666666666666)) 3.0))) (pow E (* x (* (* y y) 0.3333333333333333)))))
double code(double x, double y) {
return exp(cbrt(pow((x * (pow(y, 2.0) * 0.6666666666666666)), 3.0))) * pow(((double) M_E), (x * ((y * y) * 0.3333333333333333)));
}
public static double code(double x, double y) {
return Math.exp(Math.cbrt(Math.pow((x * (Math.pow(y, 2.0) * 0.6666666666666666)), 3.0))) * Math.pow(Math.E, (x * ((y * y) * 0.3333333333333333)));
}
function code(x, y) return Float64(exp(cbrt((Float64(x * Float64((y ^ 2.0) * 0.6666666666666666)) ^ 3.0))) * (exp(1) ^ Float64(x * Float64(Float64(y * y) * 0.3333333333333333)))) end
code[x_, y_] := N[(N[Exp[N[Power[N[Power[N[(x * N[(N[Power[y, 2.0], $MachinePrecision] * 0.6666666666666666), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]], $MachinePrecision] * N[Power[E, N[(x * N[(N[(y * y), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
e^{\sqrt[3]{{\left(x \cdot \left({y}^{2} \cdot 0.6666666666666666\right)\right)}^{3}}} \cdot {e}^{\left(x \cdot \left(\left(y \cdot y\right) \cdot 0.3333333333333333\right)\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod99.9%
add-log-exp99.9%
add-cube-cbrt99.9%
log-prod99.9%
unpow-prod-up99.9%
Applied egg-rr99.9%
associate-*r*99.9%
*-commutative99.9%
metadata-eval99.9%
*-commutative99.9%
associate-*l*99.9%
Simplified99.9%
unpow299.9%
Applied egg-rr99.9%
e-exp-199.9%
pow-exp99.9%
*-un-lft-identity99.9%
associate-*l*99.9%
Applied egg-rr99.9%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
(FPCore (x y) :precision binary64 (* (pow E (* x (* (* y y) 0.3333333333333333))) (pow E (* 0.6666666666666666 (* x (pow y 2.0))))))
double code(double x, double y) {
return pow(((double) M_E), (x * ((y * y) * 0.3333333333333333))) * pow(((double) M_E), (0.6666666666666666 * (x * pow(y, 2.0))));
}
public static double code(double x, double y) {
return Math.pow(Math.E, (x * ((y * y) * 0.3333333333333333))) * Math.pow(Math.E, (0.6666666666666666 * (x * Math.pow(y, 2.0))));
}
def code(x, y): return math.pow(math.e, (x * ((y * y) * 0.3333333333333333))) * math.pow(math.e, (0.6666666666666666 * (x * math.pow(y, 2.0))))
function code(x, y) return Float64((exp(1) ^ Float64(x * Float64(Float64(y * y) * 0.3333333333333333))) * (exp(1) ^ Float64(0.6666666666666666 * Float64(x * (y ^ 2.0))))) end
function tmp = code(x, y) tmp = (2.71828182845904523536 ^ (x * ((y * y) * 0.3333333333333333))) * (2.71828182845904523536 ^ (0.6666666666666666 * (x * (y ^ 2.0)))); end
code[x_, y_] := N[(N[Power[E, N[(x * N[(N[(y * y), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Power[E, N[(0.6666666666666666 * N[(x * N[Power[y, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{e}^{\left(x \cdot \left(\left(y \cdot y\right) \cdot 0.3333333333333333\right)\right)} \cdot {e}^{\left(0.6666666666666666 \cdot \left(x \cdot {y}^{2}\right)\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod99.9%
add-log-exp99.9%
add-cube-cbrt99.9%
log-prod99.9%
unpow-prod-up99.9%
Applied egg-rr99.9%
associate-*r*99.9%
*-commutative99.9%
metadata-eval99.9%
*-commutative99.9%
associate-*l*99.9%
Simplified99.9%
unpow299.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (x y) :precision binary64 (exp (* y (* x y))))
double code(double x, double y) {
return exp((y * (x * y)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp((y * (x * y)))
end function
public static double code(double x, double y) {
return Math.exp((y * (x * y)));
}
def code(x, y): return math.exp((y * (x * y)))
function code(x, y) return exp(Float64(y * Float64(x * y))) end
function tmp = code(x, y) tmp = exp((y * (x * y))); end
code[x_, y_] := N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{y \cdot \left(x \cdot y\right)}
\end{array}
Initial program 99.9%
Final simplification99.9%
(FPCore (x y) :precision binary64 1.0)
double code(double x, double y) {
return 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0
end function
public static double code(double x, double y) {
return 1.0;
}
def code(x, y): return 1.0
function code(x, y) return 1.0 end
function tmp = code(x, y) tmp = 1.0; end
code[x_, y_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 99.9%
Taylor expanded in x around 0 55.9%
herbie shell --seed 2024180
(FPCore (x y)
:name "Data.Random.Distribution.Normal:normalF from random-fu-0.2.6.2"
:precision binary64
(exp (* (* x y) y)))