
(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 6 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 (pow (cbrt (exp 6.0)) (* x (/ (pow y 2.0) 2.0))))
double code(double x, double y) {
return pow(cbrt(exp(6.0)), (x * (pow(y, 2.0) / 2.0)));
}
public static double code(double x, double y) {
return Math.pow(Math.cbrt(Math.exp(6.0)), (x * (Math.pow(y, 2.0) / 2.0)));
}
function code(x, y) return cbrt(exp(6.0)) ^ Float64(x * Float64((y ^ 2.0) / 2.0)) end
code[x_, y_] := N[Power[N[Power[N[Exp[6.0], $MachinePrecision], 1/3], $MachinePrecision], N[(x * N[(N[Power[y, 2.0], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
{\left(\sqrt[3]{e^{6}}\right)}^{\left(x \cdot \frac{{y}^{2}}{2}\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod100.0%
add-cube-cbrt99.9%
exp-1-e99.9%
add-cube-cbrt100.0%
associate-*l*100.0%
pow2100.0%
Applied egg-rr100.0%
add-cbrt-cube99.6%
pow1/399.6%
pow-to-exp99.6%
pow399.6%
log-pow100.0%
e-exp-1100.0%
pow-exp100.0%
*-un-lft-identity100.0%
add-log-exp100.0%
Applied egg-rr100.0%
*-commutative100.0%
pow-exp100.0%
sqr-pow100.0%
pow-prod-down100.0%
pow2100.0%
add-cbrt-cube99.9%
pow399.9%
pow-exp99.9%
metadata-eval99.9%
e-exp-199.9%
pow299.9%
pow299.9%
associate-/l*99.9%
pow-unpow99.9%
Applied egg-rr100.0%
add-cbrt-cube99.9%
add-exp-log100.0%
pow3100.0%
log-pow100.0%
pow-exp100.0%
metadata-eval100.0%
rem-log-exp100.0%
metadata-eval100.0%
Applied egg-rr100.0%
(FPCore (x y) :precision binary64 (pow (exp 0.3333333333333333) (* 3.0 (* x (* y y)))))
double code(double x, double y) {
return pow(exp(0.3333333333333333), (3.0 * (x * (y * y))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp(0.3333333333333333d0) ** (3.0d0 * (x * (y * y)))
end function
public static double code(double x, double y) {
return Math.pow(Math.exp(0.3333333333333333), (3.0 * (x * (y * y))));
}
def code(x, y): return math.pow(math.exp(0.3333333333333333), (3.0 * (x * (y * y))))
function code(x, y) return exp(0.3333333333333333) ^ Float64(3.0 * Float64(x * Float64(y * y))) end
function tmp = code(x, y) tmp = exp(0.3333333333333333) ^ (3.0 * (x * (y * y))); end
code[x_, y_] := N[Power[N[Exp[0.3333333333333333], $MachinePrecision], N[(3.0 * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
{\left(e^{0.3333333333333333}\right)}^{\left(3 \cdot \left(x \cdot \left(y \cdot y\right)\right)\right)}
\end{array}
Initial program 99.9%
add-cbrt-cube99.6%
pow399.6%
Applied egg-rr99.6%
rem-cbrt-cube99.9%
associate-*r*99.9%
unpow299.9%
*-un-lft-identity99.9%
pow-exp100.0%
e-exp-1100.0%
add-cube-cbrt99.9%
pow399.9%
pow-pow99.9%
pow1/3100.0%
pow-to-exp100.0%
log-E100.0%
metadata-eval100.0%
Applied egg-rr100.0%
unpow2100.0%
Applied egg-rr100.0%
(FPCore (x y) :precision binary64 (exp (* 0.3333333333333333 (* 3.0 (* x (* y y))))))
double code(double x, double y) {
return exp((0.3333333333333333 * (3.0 * (x * (y * y)))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp((0.3333333333333333d0 * (3.0d0 * (x * (y * y)))))
end function
public static double code(double x, double y) {
return Math.exp((0.3333333333333333 * (3.0 * (x * (y * y)))));
}
def code(x, y): return math.exp((0.3333333333333333 * (3.0 * (x * (y * y)))))
function code(x, y) return exp(Float64(0.3333333333333333 * Float64(3.0 * Float64(x * Float64(y * y))))) end
function tmp = code(x, y) tmp = exp((0.3333333333333333 * (3.0 * (x * (y * y))))); end
code[x_, y_] := N[Exp[N[(0.3333333333333333 * N[(3.0 * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{0.3333333333333333 \cdot \left(3 \cdot \left(x \cdot \left(y \cdot y\right)\right)\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod100.0%
add-cube-cbrt99.9%
exp-1-e99.9%
add-cube-cbrt100.0%
associate-*l*100.0%
pow2100.0%
Applied egg-rr100.0%
add-cbrt-cube99.6%
pow1/399.6%
pow-to-exp99.6%
pow399.6%
log-pow100.0%
e-exp-1100.0%
pow-exp100.0%
*-un-lft-identity100.0%
add-log-exp100.0%
Applied egg-rr100.0%
unpow2100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (pow E (* x (* y y))))
double code(double x, double y) {
return pow(((double) M_E), (x * (y * y)));
}
public static double code(double x, double y) {
return Math.pow(Math.E, (x * (y * y)));
}
def code(x, y): return math.pow(math.e, (x * (y * y)))
function code(x, y) return exp(1) ^ Float64(x * Float64(y * y)) end
function tmp = code(x, y) tmp = 2.71828182845904523536 ^ (x * (y * y)); end
code[x_, y_] := N[Power[E, N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
{e}^{\left(x \cdot \left(y \cdot y\right)\right)}
\end{array}
Initial program 99.9%
*-un-lft-identity99.9%
exp-prod100.0%
add-cube-cbrt99.9%
exp-1-e99.9%
add-cube-cbrt100.0%
associate-*l*100.0%
pow2100.0%
Applied egg-rr100.0%
unpow2100.0%
Applied egg-rr100.0%
(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 48.7%
herbie shell --seed 2024170
(FPCore (x y)
:name "Data.Random.Distribution.Normal:normalF from random-fu-0.2.6.2"
:precision binary64
(exp (* (* x y) y)))