
(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 17 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) (* x (fma y y 1.0)) (* x (fma (* y y) (fma y 0.16666666666666666 0.5) y))))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 2.0) {
tmp = x * fma(y, y, 1.0);
} else {
tmp = x * fma((y * y), fma(y, 0.16666666666666666, 0.5), y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 2.0) tmp = Float64(x * fma(y, y, 1.0)); else tmp = Float64(x * fma(Float64(y * y), fma(y, 0.16666666666666666, 0.5), y)); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 2.0], N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * 0.16666666666666666 + 0.5), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 2:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(y, 0.16666666666666666, 0.5\right), y\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 2Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f64100.0
Simplified100.0%
if 2 < (exp.f64 (*.f64 y y)) Initial program 99.9%
*-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
associate-*r/N/A
Applied egg-rr52.1%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6442.9
Simplified42.9%
Taylor expanded in y around inf
associate-+r+N/A
distribute-rgt-inN/A
*-commutativeN/A
unpow3N/A
unpow2N/A
associate-*l*N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
lft-mult-inverseN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
distribute-lft-inN/A
*-commutativeN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
accelerator-lowering-fma.f6442.9
Simplified42.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%
*-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
associate-*r/N/A
Applied egg-rr75.8%
(FPCore (x y) :precision binary64 (* x (fma y (fma (* y y) (* y (fma y (* y 0.16666666666666666) 0.5)) y) 1.0)))
double code(double x, double y) {
return x * fma(y, fma((y * y), (y * fma(y, (y * 0.16666666666666666), 0.5)), y), 1.0);
}
function code(x, y) return Float64(x * fma(y, fma(Float64(y * y), Float64(y * fma(y, Float64(y * 0.16666666666666666), 0.5)), y), 1.0)) end
code[x_, y_] := N[(x * N[(y * N[(N[(y * y), $MachinePrecision] * N[(y * N[(y * N[(y * 0.16666666666666666), $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y \cdot y, y \cdot \mathsf{fma}\left(y, y \cdot 0.16666666666666666, 0.5\right), y\right), 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
Simplified93.4%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5e-8) (* x (fma y y 1.0)) (* x (* y (fma y (* (* y y) 0.5) y)))))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x * fma(y, y, 1.0);
} else {
tmp = x * (y * fma(y, ((y * y) * 0.5), y));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5e-8) tmp = Float64(x * fma(y, y, 1.0)); else tmp = Float64(x * Float64(y * fma(y, Float64(Float64(y * y) * 0.5), y))); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5e-8], N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision], N[(x * N[(y * N[(y * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{-8}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot \mathsf{fma}\left(y, \left(y \cdot y\right) \cdot 0.5, y\right)\right)\\
\end{array}
\end{array}
if (*.f64 y y) < 4.9999999999999998e-8Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f64100.0
Simplified100.0%
if 4.9999999999999998e-8 < (*.f64 y y) Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6484.1
Simplified84.1%
Taylor expanded in y around inf
*-commutativeN/A
metadata-evalN/A
pow-plusN/A
associate-*l*N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
unpow3N/A
unpow2N/A
associate-*r*N/A
lft-mult-inverseN/A
*-lft-identityN/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
Simplified84.1%
Final simplification92.2%
(FPCore (x y) :precision binary64 (* x (fma y (fma (* y y) (* y (* (* y y) 0.16666666666666666)) y) 1.0)))
double code(double x, double y) {
return x * fma(y, fma((y * y), (y * ((y * y) * 0.16666666666666666)), y), 1.0);
}
function code(x, y) return Float64(x * fma(y, fma(Float64(y * y), Float64(y * Float64(Float64(y * y) * 0.16666666666666666)), y), 1.0)) end
code[x_, y_] := N[(x * N[(y * N[(N[(y * y), $MachinePrecision] * N[(y * N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y \cdot y, y \cdot \left(\left(y \cdot y\right) \cdot 0.16666666666666666\right), y\right), 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
Simplified93.4%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6493.4
Simplified93.4%
Final simplification93.4%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5e-8) (* x (fma y y 1.0)) (* x (* y (* 0.5 (* y (* y y)))))))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x * fma(y, y, 1.0);
} else {
tmp = x * (y * (0.5 * (y * (y * y))));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5e-8) tmp = Float64(x * fma(y, y, 1.0)); else tmp = Float64(x * Float64(y * Float64(0.5 * Float64(y * Float64(y * y))))); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5e-8], N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision], N[(x * N[(y * N[(0.5 * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{-8}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot \left(0.5 \cdot \left(y \cdot \left(y \cdot y\right)\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 y y) < 4.9999999999999998e-8Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f64100.0
Simplified100.0%
if 4.9999999999999998e-8 < (*.f64 y y) Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6484.1
Simplified84.1%
Taylor expanded in y around inf
metadata-evalN/A
pow-plusN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6484.0
Simplified84.0%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5.0) (* x (fma y y 1.0)) (* x (* y (* y (fma y 0.16666666666666666 0.5))))))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5.0) {
tmp = x * fma(y, y, 1.0);
} else {
tmp = x * (y * (y * fma(y, 0.16666666666666666, 0.5)));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5.0) tmp = Float64(x * fma(y, y, 1.0)); else tmp = Float64(x * Float64(y * Float64(y * fma(y, 0.16666666666666666, 0.5)))); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5.0], N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision], N[(x * N[(y * N[(y * N[(y * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot \left(y \cdot \mathsf{fma}\left(y, 0.16666666666666666, 0.5\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 y y) < 5Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f6499.3
Simplified99.3%
if 5 < (*.f64 y y) Initial program 100.0%
*-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
associate-*r/N/A
Applied egg-rr52.5%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6443.2
Simplified43.2%
Taylor expanded in y around inf
cube-multN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
distribute-lft-inN/A
*-commutativeN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
accelerator-lowering-fma.f6443.2
Simplified43.2%
(FPCore (x y) :precision binary64 (if (<= (* y y) 20.0) (* x (fma y y 1.0)) (* x (* y (* (* y y) 0.16666666666666666)))))
double code(double x, double y) {
double tmp;
if ((y * y) <= 20.0) {
tmp = x * fma(y, y, 1.0);
} else {
tmp = x * (y * ((y * y) * 0.16666666666666666));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 20.0) tmp = Float64(x * fma(y, y, 1.0)); else tmp = Float64(x * Float64(y * Float64(Float64(y * y) * 0.16666666666666666))); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 20.0], N[(x * N[(y * y + 1.0), $MachinePrecision]), $MachinePrecision], N[(x * N[(y * N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 20:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot \left(\left(y \cdot y\right) \cdot 0.16666666666666666\right)\right)\\
\end{array}
\end{array}
if (*.f64 y y) < 20Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f6498.7
Simplified98.7%
if 20 < (*.f64 y y) Initial program 100.0%
*-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
associate-*r/N/A
Applied egg-rr52.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6443.5
Simplified43.5%
Taylor expanded in y around inf
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6443.5
Simplified43.5%
Final simplification72.2%
(FPCore (x y) :precision binary64 (* x (fma y (fma y (* (* y y) 0.5) y) 1.0)))
double code(double x, double y) {
return x * fma(y, fma(y, ((y * y) * 0.5), y), 1.0);
}
function code(x, y) return Float64(x * fma(y, fma(y, Float64(Float64(y * y) * 0.5), y), 1.0)) end
code[x_, y_] := N[(x * N[(y * N[(y * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y, \left(y \cdot y\right) \cdot 0.5, y\right), 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6492.2
Simplified92.2%
(FPCore (x y) :precision binary64 (* x (fma y (fma y (fma y 0.16666666666666666 0.5) 1.0) 1.0)))
double code(double x, double y) {
return x * fma(y, fma(y, fma(y, 0.16666666666666666, 0.5), 1.0), 1.0);
}
function code(x, y) return Float64(x * fma(y, fma(y, fma(y, 0.16666666666666666, 0.5), 1.0), 1.0)) end
code[x_, y_] := N[(x * N[(y * N[(y * N[(y * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.16666666666666666, 0.5\right), 1\right), 1\right)
\end{array}
Initial program 100.0%
*-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
associate-*r/N/A
Applied egg-rr75.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6471.3
Simplified71.3%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5e-8) x (* x (* y y))))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x;
} 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 ((y * y) <= 5d-8) then
tmp = x
else
tmp = x * (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x;
} else {
tmp = x * (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if (y * y) <= 5e-8: tmp = x else: tmp = x * (y * y) return tmp
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5e-8) tmp = x; else tmp = Float64(x * Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y * y) <= 5e-8) tmp = x; else tmp = x * (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5e-8], x, N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{-8}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot y\right)\\
\end{array}
\end{array}
if (*.f64 y y) < 4.9999999999999998e-8Initial program 100.0%
Taylor expanded in y around 0
Simplified99.3%
if 4.9999999999999998e-8 < (*.f64 y y) Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f6469.5
Simplified69.5%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6469.5
Simplified69.5%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5e-8) x (* x y)))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x;
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y * y) <= 5d-8) then
tmp = x
else
tmp = x * y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y * y) <= 5e-8) {
tmp = x;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y): tmp = 0 if (y * y) <= 5e-8: tmp = x else: tmp = x * y return tmp
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5e-8) tmp = x; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y * y) <= 5e-8) tmp = x; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5e-8], x, N[(x * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{-8}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 y y) < 4.9999999999999998e-8Initial program 100.0%
Taylor expanded in y around 0
Simplified99.3%
if 4.9999999999999998e-8 < (*.f64 y y) Initial program 99.9%
*-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
associate-*r/N/A
Applied egg-rr52.1%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f6416.5
Simplified16.5%
Taylor expanded in y around inf
*-lowering-*.f6416.5
Simplified16.5%
(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
accelerator-lowering-fma.f6485.1
Simplified85.1%
(FPCore (x y) :precision binary64 (* x (+ y 1.0)))
double code(double x, double y) {
return x * (y + 1.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (y + 1.0d0)
end function
public static double code(double x, double y) {
return x * (y + 1.0);
}
def code(x, y): return x * (y + 1.0)
function code(x, y) return Float64(x * Float64(y + 1.0)) end
function tmp = code(x, y) tmp = x * (y + 1.0); end
code[x_, y_] := N[(x * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(y + 1\right)
\end{array}
Initial program 100.0%
*-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
associate-*r/N/A
Applied egg-rr75.8%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f6458.4
Simplified58.4%
(FPCore (x y) :precision binary64 (fma x y x))
double code(double x, double y) {
return fma(x, y, x);
}
function code(x, y) return fma(x, y, x) end
code[x_, y_] := N[(x * y + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y, x\right)
\end{array}
Initial program 100.0%
*-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
associate-*r/N/A
Applied egg-rr75.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f6458.4
Simplified58.4%
(FPCore (x y) :precision binary64 x)
double code(double x, double y) {
return x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x
end function
public static double code(double x, double y) {
return x;
}
def code(x, y): return x
function code(x, y) return x end
function tmp = code(x, y) tmp = x; end
code[x_, y_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
Simplified52.8%
(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 2024198
(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))))