
(FPCore (x y) :precision binary64 (* x (exp (* y y))))
double code(double x, double y) {
return x * exp((y * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * exp((y * y))
end function
public static double code(double x, double y) {
return x * Math.exp((y * y));
}
def code(x, y): return x * math.exp((y * y))
function code(x, y) return Float64(x * exp(Float64(y * y))) end
function tmp = code(x, y) tmp = x * exp((y * y)); end
code[x_, y_] := N[(x * N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (* x (exp (* y y))))
double code(double x, double y) {
return x * exp((y * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * exp((y * y))
end function
public static double code(double x, double y) {
return x * Math.exp((y * y));
}
def code(x, y): return x * math.exp((y * y))
function code(x, y) return Float64(x * exp(Float64(y * y))) end
function tmp = code(x, y) tmp = x * exp((y * y)); end
code[x_, y_] := N[(x * N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot y}
\end{array}
(FPCore (x y) :precision binary64 (* x (exp (* y y))))
double code(double x, double y) {
return x * exp((y * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * exp((y * y))
end function
public static double code(double x, double y) {
return x * Math.exp((y * y));
}
def code(x, y): return x * math.exp((y * y))
function code(x, y) return Float64(x * exp(Float64(y * y))) end
function tmp = code(x, y) tmp = x * exp((y * y)); end
code[x_, y_] := N[(x * N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot y}
\end{array}
Initial program 100.0%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 2.0) (fma (* y x) y x) (* x (* (* (fma 0.16666666666666666 y 0.5) y) y))))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 2.0) {
tmp = fma((y * x), y, x);
} else {
tmp = x * ((fma(0.16666666666666666, y, 0.5) * y) * y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 2.0) tmp = fma(Float64(y * x), y, x); else tmp = Float64(x * Float64(Float64(fma(0.16666666666666666, y, 0.5) * y) * y)); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(x * N[(N[(N[(0.16666666666666666 * y + 0.5), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(\left(\mathsf{fma}\left(0.16666666666666666, y, 0.5\right) \cdot y\right) \cdot y\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 2Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites99.2%
Taylor expanded in y around 0
Applied rewrites82.0%
Taylor expanded in y around 0
Applied rewrites99.6%
if 2 < (exp.f64 (*.f64 y y)) Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites52.3%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6436.2
Applied rewrites36.2%
Taylor expanded in y around inf
Applied rewrites36.2%
Taylor expanded in y around inf
Applied rewrites36.2%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 2.0) (fma (* y x) y x) (* x (* (* 0.16666666666666666 y) (* y y)))))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 2.0) {
tmp = fma((y * x), y, x);
} else {
tmp = x * ((0.16666666666666666 * y) * (y * y));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 2.0) tmp = fma(Float64(y * x), y, x); else tmp = Float64(x * Float64(Float64(0.16666666666666666 * y) * Float64(y * y))); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(x * N[(N[(0.16666666666666666 * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(\left(0.16666666666666666 \cdot y\right) \cdot \left(y \cdot y\right)\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 2Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites99.2%
Taylor expanded in y around 0
Applied rewrites82.0%
Taylor expanded in y around 0
Applied rewrites99.6%
if 2 < (exp.f64 (*.f64 y y)) Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites52.3%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6436.2
Applied rewrites36.2%
Taylor expanded in y around inf
Applied rewrites36.2%
Taylor expanded in y around inf
Applied rewrites36.2%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 2.0) (fma (* y x) y x) (* x (* y y))))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 2.0) {
tmp = fma((y * x), y, x);
} else {
tmp = x * (y * y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 2.0) tmp = fma(Float64(y * x), y, x); else tmp = Float64(x * Float64(y * y)); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot y\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 2Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites99.2%
Taylor expanded in y around 0
Applied rewrites82.0%
Taylor expanded in y around 0
Applied rewrites99.6%
if 2 < (exp.f64 (*.f64 y y)) Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
lower-fma.f6460.9
Applied rewrites60.9%
Taylor expanded in y around inf
Applied rewrites60.9%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 2.0) (* x 1.0) (* x (* y y))))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 2.0) {
tmp = x * 1.0;
} else {
tmp = x * (y * y);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (exp((y * y)) <= 2.0d0) then
tmp = x * 1.0d0
else
tmp = x * (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (Math.exp((y * y)) <= 2.0) {
tmp = x * 1.0;
} else {
tmp = x * (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if math.exp((y * y)) <= 2.0: tmp = x * 1.0 else: tmp = x * (y * y) return tmp
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 2.0) tmp = Float64(x * 1.0); else tmp = Float64(x * Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (exp((y * y)) <= 2.0) tmp = x * 1.0; else tmp = x * (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 2.0], N[(x * 1.0), $MachinePrecision], N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 2:\\
\;\;\;\;x \cdot 1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot y\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 2Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites99.2%
if 2 < (exp.f64 (*.f64 y y)) Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
lower-fma.f6460.9
Applied rewrites60.9%
Taylor expanded in y around inf
Applied rewrites60.9%
(FPCore (x y) :precision binary64 (* x (exp y)))
double code(double x, double y) {
return x * exp(y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * exp(y)
end function
public static double code(double x, double y) {
return x * Math.exp(y);
}
def code(x, y): return x * math.exp(y)
function code(x, y) return Float64(x * exp(y)) end
function tmp = code(x, y) tmp = x * exp(y); end
code[x_, y_] := N[(x * N[Exp[y], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y}
\end{array}
Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites75.0%
(FPCore (x y) :precision binary64 (fma (* (fma (* x (fma 0.16666666666666666 (* y y) 0.5)) (* y y) x) y) y x))
double code(double x, double y) {
return fma((fma((x * fma(0.16666666666666666, (y * y), 0.5)), (y * y), x) * y), y, x);
}
function code(x, y) return fma(Float64(fma(Float64(x * fma(0.16666666666666666, Float64(y * y), 0.5)), Float64(y * y), x) * y), y, x) end
code[x_, y_] := N[(N[(N[(N[(x * N[(0.16666666666666666 * N[(y * y), $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision] * y), $MachinePrecision] * y + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(x \cdot \mathsf{fma}\left(0.16666666666666666, y \cdot y, 0.5\right), y \cdot y, x\right) \cdot y, y, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites50.7%
Taylor expanded in y around 0
Applied rewrites81.5%
Taylor expanded in y around 0
Applied rewrites90.3%
Applied rewrites90.3%
(FPCore (x y) :precision binary64 (fma (fma (* (* (* y y) 0.16666666666666666) x) (* y y) x) (* y y) x))
double code(double x, double y) {
return fma(fma((((y * y) * 0.16666666666666666) * x), (y * y), x), (y * y), x);
}
function code(x, y) return fma(fma(Float64(Float64(Float64(y * y) * 0.16666666666666666) * x), Float64(y * y), x), Float64(y * y), x) end
code[x_, y_] := N[(N[(N[(N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] * x), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(\left(\left(y \cdot y\right) \cdot 0.16666666666666666\right) \cdot x, y \cdot y, x\right), y \cdot y, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites50.7%
Taylor expanded in y around 0
Applied rewrites81.5%
Taylor expanded in y around 0
Applied rewrites90.3%
Taylor expanded in y around inf
Applied rewrites90.2%
(FPCore (x y) :precision binary64 (fma (fma (* 0.5 x) (* y y) x) (* y y) x))
double code(double x, double y) {
return fma(fma((0.5 * x), (y * y), x), (y * y), x);
}
function code(x, y) return fma(fma(Float64(0.5 * x), Float64(y * y), x), Float64(y * y), x) end
code[x_, y_] := N[(N[(N[(0.5 * x), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(0.5 \cdot x, y \cdot y, x\right), y \cdot y, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites50.7%
Taylor expanded in y around 0
Applied rewrites81.5%
Taylor expanded in y around 0
Applied rewrites90.3%
Taylor expanded in y around 0
Applied rewrites86.5%
(FPCore (x y) :precision binary64 (* x (fma (* (fma 0.16666666666666666 y 0.5) y) y 1.0)))
double code(double x, double y) {
return x * fma((fma(0.16666666666666666, y, 0.5) * y), y, 1.0);
}
function code(x, y) return Float64(x * fma(Float64(fma(0.16666666666666666, y, 0.5) * y), y, 1.0)) end
code[x_, y_] := N[(x * N[(N[(N[(0.16666666666666666 * y + 0.5), $MachinePrecision] * y), $MachinePrecision] * y + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(\mathsf{fma}\left(0.16666666666666666, y, 0.5\right) \cdot y, y, 1\right)
\end{array}
Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites75.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6466.9
Applied rewrites66.9%
Taylor expanded in y around inf
Applied rewrites67.2%
(FPCore (x y) :precision binary64 (* x (fma (* (* y y) 0.16666666666666666) y 1.0)))
double code(double x, double y) {
return x * fma(((y * y) * 0.16666666666666666), y, 1.0);
}
function code(x, y) return Float64(x * fma(Float64(Float64(y * y) * 0.16666666666666666), y, 1.0)) end
code[x_, y_] := N[(x * N[(N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] * y + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(\left(y \cdot y\right) \cdot 0.16666666666666666, y, 1\right)
\end{array}
Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites75.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6466.9
Applied rewrites66.9%
Taylor expanded in y around inf
Applied rewrites67.2%
(FPCore (x y) :precision binary64 (if (<= y 1.0) (* x 1.0) (* y x)))
double code(double x, double y) {
double tmp;
if (y <= 1.0) {
tmp = x * 1.0;
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.0d0) then
tmp = x * 1.0d0
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 1.0) {
tmp = x * 1.0;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 1.0: tmp = x * 1.0 else: tmp = y * x return tmp
function code(x, y) tmp = 0.0 if (y <= 1.0) tmp = Float64(x * 1.0); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 1.0) tmp = x * 1.0; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 1.0], N[(x * 1.0), $MachinePrecision], N[(y * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1:\\
\;\;\;\;x \cdot 1\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if y < 1Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites67.4%
if 1 < y Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6423.9
Applied rewrites23.9%
Taylor expanded in y around inf
Applied rewrites23.9%
(FPCore (x y) :precision binary64 (* x (fma y y 1.0)))
double code(double x, double y) {
return x * fma(y, y, 1.0);
}
function code(x, y) return Float64(x * fma(y, y, 1.0)) end
code[x_, y_] := N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(y, y, 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
lower-fma.f6480.0
Applied rewrites80.0%
(FPCore (x y) :precision binary64 (fma y x x))
double code(double x, double y) {
return fma(y, x, x);
}
function code(x, y) return fma(y, x, x) end
code[x_, y_] := N[(y * x + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y, x, x\right)
\end{array}
Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites75.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6454.8
Applied rewrites54.8%
(FPCore (x y) :precision binary64 (* y x))
double code(double x, double y) {
return y * x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = y * x
end function
public static double code(double x, double y) {
return y * x;
}
def code(x, y): return y * x
function code(x, y) return Float64(y * x) end
function tmp = code(x, y) tmp = y * x; end
code[x_, y_] := N[(y * x), $MachinePrecision]
\begin{array}{l}
\\
y \cdot x
\end{array}
Initial program 100.0%
lift-*.f64N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
flip-+N/A
+-inversesN/A
+-inversesN/A
associate-*r/N/A
*-rgt-identityN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
distribute-lft-outN/A
div-invN/A
div-invN/A
+-inversesN/A
difference-of-squaresN/A
+-inversesN/A
flip-+N/A
count-2N/A
Applied rewrites75.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6454.8
Applied rewrites54.8%
Taylor expanded in y around inf
Applied rewrites8.4%
(FPCore (x y) :precision binary64 (* x (pow (exp y) y)))
double code(double x, double y) {
return x * pow(exp(y), y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (exp(y) ** y)
end function
public static double code(double x, double y) {
return x * Math.pow(Math.exp(y), y);
}
def code(x, y): return x * math.pow(math.exp(y), y)
function code(x, y) return Float64(x * (exp(y) ^ y)) end
function tmp = code(x, y) tmp = x * (exp(y) ^ y); end
code[x_, y_] := N[(x * N[Power[N[Exp[y], $MachinePrecision], y], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot {\left(e^{y}\right)}^{y}
\end{array}
herbie shell --seed 2024324
(FPCore (x y)
:name "Data.Number.Erf:$dmerfcx from erf-2.0.0.0"
:precision binary64
:alt
(! :herbie-platform default (* x (pow (exp y) y)))
(* x (exp (* y y))))