
(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 20 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 (* 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 100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(if (<= (exp (* y (* x y))) 0.0)
(exp (* x y))
(fma
(* (* y y) (* (* y y) (* x (fma (* x (* y y)) 0.16666666666666666 0.5))))
x
(fma x (* y y) 1.0))))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 0.0) {
tmp = exp((x * y));
} else {
tmp = fma(((y * y) * ((y * y) * (x * fma((x * (y * y)), 0.16666666666666666, 0.5)))), x, fma(x, (y * y), 1.0));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 0.0) tmp = exp(Float64(x * y)); else tmp = fma(Float64(Float64(y * y) * Float64(Float64(y * y) * Float64(x * fma(Float64(x * Float64(y * y)), 0.16666666666666666, 0.5)))), x, fma(x, Float64(y * y), 1.0)); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[Exp[N[(x * y), $MachinePrecision]], $MachinePrecision], N[(N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x + N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 0:\\
\;\;\;\;e^{x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(y \cdot y\right) \cdot \left(\left(y \cdot y\right) \cdot \left(x \cdot \mathsf{fma}\left(x \cdot \left(y \cdot y\right), 0.16666666666666666, 0.5\right)\right)\right), x, \mathsf{fma}\left(x, y \cdot y, 1\right)\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 0.0Initial program 100.0%
Applied egg-rr44.9%
if 0.0 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Taylor expanded in x around 0
Simplified92.0%
distribute-lft-inN/A
*-rgt-identityN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
Applied egg-rr93.0%
Final simplification82.3%
(FPCore (x y)
:precision binary64
(if (<= (exp (* y (* x y))) 0.0)
(exp x)
(fma
(* (* y y) (* (* y y) (* x (fma (* x (* y y)) 0.16666666666666666 0.5))))
x
(fma x (* y y) 1.0))))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 0.0) {
tmp = exp(x);
} else {
tmp = fma(((y * y) * ((y * y) * (x * fma((x * (y * y)), 0.16666666666666666, 0.5)))), x, fma(x, (y * y), 1.0));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 0.0) tmp = exp(x); else tmp = fma(Float64(Float64(y * y) * Float64(Float64(y * y) * Float64(x * fma(Float64(x * Float64(y * y)), 0.16666666666666666, 0.5)))), x, fma(x, Float64(y * y), 1.0)); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[Exp[x], $MachinePrecision], N[(N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x + N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 0:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(y \cdot y\right) \cdot \left(\left(y \cdot y\right) \cdot \left(x \cdot \mathsf{fma}\left(x \cdot \left(y \cdot y\right), 0.16666666666666666, 0.5\right)\right)\right), x, \mathsf{fma}\left(x, y \cdot y, 1\right)\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 0.0Initial program 100.0%
Applied egg-rr71.1%
if 0.0 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Taylor expanded in x around 0
Simplified92.0%
distribute-lft-inN/A
*-rgt-identityN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
Applied egg-rr93.0%
Final simplification88.1%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) (fma (* (* x y) (fma (* x y) (* y 0.5) 1.0)) y 1.0) (fma x (fma x (* (* y y) (fma y (* x 0.16666666666666666) 0.5)) y) 1.0)))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
tmp = fma(((x * y) * fma((x * y), (y * 0.5), 1.0)), y, 1.0);
} else {
tmp = fma(x, fma(x, ((y * y) * fma(y, (x * 0.16666666666666666), 0.5)), y), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = fma(Float64(Float64(x * y) * fma(Float64(x * y), Float64(y * 0.5), 1.0)), y, 1.0); else tmp = fma(x, fma(x, Float64(Float64(y * y) * fma(y, Float64(x * 0.16666666666666666), 0.5)), y), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(N[(x * y), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] * N[(y * 0.5), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(x * N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * N[(x * 0.16666666666666666), $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(\left(x \cdot y\right) \cdot \mathsf{fma}\left(x \cdot y, y \cdot 0.5, 1\right), y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot \mathsf{fma}\left(y, x \cdot 0.16666666666666666, 0.5\right), y\right), 1\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified67.6%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6467.6
Applied egg-rr67.6%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Applied egg-rr40.7%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
cube-multN/A
unpow2N/A
associate-*r*N/A
distribute-rgt-outN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6438.9
Simplified38.9%
Final simplification58.5%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) (fma (* x y) y 1.0) (* y (* 0.16666666666666666 (* x (* x (* x (* y y))))))))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
tmp = fma((x * y), y, 1.0);
} else {
tmp = y * (0.16666666666666666 * (x * (x * (x * (y * y)))));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = fma(Float64(x * y), y, 1.0); else tmp = Float64(y * Float64(0.16666666666666666 * Float64(x * Float64(x * Float64(x * Float64(y * y)))))); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(x * y), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(y * N[(0.16666666666666666 * N[(x * N[(x * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(x \cdot y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(0.16666666666666666 \cdot \left(x \cdot \left(x \cdot \left(x \cdot \left(y \cdot y\right)\right)\right)\right)\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6467.4
Simplified67.4%
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6467.5
Applied egg-rr67.5%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Applied egg-rr40.7%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
cube-multN/A
unpow2N/A
associate-*r*N/A
distribute-rgt-outN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6438.9
Simplified38.9%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
unpow3N/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6429.0
Simplified29.0%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
unpow2N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6435.2
Simplified35.2%
Final simplification57.3%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) (fma (* x y) y 1.0) (* x (* 0.5 (* x (* (* y y) (* y y)))))))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
tmp = fma((x * y), y, 1.0);
} else {
tmp = x * (0.5 * (x * ((y * y) * (y * y))));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = fma(Float64(x * y), y, 1.0); else tmp = Float64(x * Float64(0.5 * Float64(x * Float64(Float64(y * y) * Float64(y * y))))); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(x * y), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(x * N[(0.5 * N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(x \cdot y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(0.5 \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot \left(y \cdot y\right)\right)\right)\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6467.4
Simplified67.4%
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6467.5
Applied egg-rr67.5%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified73.0%
Taylor expanded in x around inf
*-commutativeN/A
associate-*r*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6478.9
Simplified78.9%
Final simplification71.1%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) (fma (* x y) y 1.0) (fma x (fma x (* (* y y) 0.5) y) 1.0)))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
tmp = fma((x * y), y, 1.0);
} else {
tmp = fma(x, fma(x, ((y * y) * 0.5), y), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = fma(Float64(x * y), y, 1.0); else tmp = fma(x, fma(x, Float64(Float64(y * y) * 0.5), y), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], N[(N[(x * y), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(x * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + y), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;\mathsf{fma}\left(x \cdot y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.5, y\right), 1\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6467.4
Simplified67.4%
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6467.5
Applied egg-rr67.5%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Applied egg-rr40.7%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
cube-multN/A
unpow2N/A
associate-*r*N/A
distribute-rgt-outN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6438.9
Simplified38.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6476.5
Simplified76.5%
Final simplification70.3%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) 1.0 (fma x y 1.0)))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
tmp = 1.0;
} else {
tmp = fma(x, y, 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = 1.0; else tmp = fma(x, y, 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], 1.0, N[(x * y + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, y, 1\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Applied egg-rr67.4%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Applied egg-rr40.7%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f6415.4
Simplified15.4%
Final simplification51.0%
(FPCore (x y)
:precision binary64
(if (<= y 3.5e-77)
(fma (* (* x y) (fma (* x y) (* y 0.5) 1.0)) y 1.0)
(if (<= y 1.4e+87)
(fma
(* y y)
(* (* y y) (* (* y y) (* x (* 0.16666666666666666 (* x x)))))
1.0)
(* x (* 0.5 (* x (* (* y y) (* y y))))))))
double code(double x, double y) {
double tmp;
if (y <= 3.5e-77) {
tmp = fma(((x * y) * fma((x * y), (y * 0.5), 1.0)), y, 1.0);
} else if (y <= 1.4e+87) {
tmp = fma((y * y), ((y * y) * ((y * y) * (x * (0.16666666666666666 * (x * x))))), 1.0);
} else {
tmp = x * (0.5 * (x * ((y * y) * (y * y))));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3.5e-77) tmp = fma(Float64(Float64(x * y) * fma(Float64(x * y), Float64(y * 0.5), 1.0)), y, 1.0); elseif (y <= 1.4e+87) tmp = fma(Float64(y * y), Float64(Float64(y * y) * Float64(Float64(y * y) * Float64(x * Float64(0.16666666666666666 * Float64(x * x))))), 1.0); else tmp = Float64(x * Float64(0.5 * Float64(x * Float64(Float64(y * y) * Float64(y * y))))); end return tmp end
code[x_, y_] := If[LessEqual[y, 3.5e-77], N[(N[(N[(x * y), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] * N[(y * 0.5), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision], If[LessEqual[y, 1.4e+87], N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(x * N[(0.16666666666666666 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(0.5 * N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.5 \cdot 10^{-77}:\\
\;\;\;\;\mathsf{fma}\left(\left(x \cdot y\right) \cdot \mathsf{fma}\left(x \cdot y, y \cdot 0.5, 1\right), y, 1\right)\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, \left(y \cdot y\right) \cdot \left(\left(y \cdot y\right) \cdot \left(x \cdot \left(0.16666666666666666 \cdot \left(x \cdot x\right)\right)\right)\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(0.5 \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot \left(y \cdot y\right)\right)\right)\right)\\
\end{array}
\end{array}
if y < 3.50000000000000013e-77Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified78.2%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.7
Applied egg-rr78.7%
if 3.50000000000000013e-77 < y < 1.40000000000000008e87Initial program 100.0%
Taylor expanded in x around 0
Simplified53.1%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified60.8%
Taylor expanded in y around inf
associate-*r*N/A
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6460.7
Simplified60.7%
if 1.40000000000000008e87 < y Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified53.0%
Taylor expanded in x around inf
*-commutativeN/A
associate-*r*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6459.0
Simplified59.0%
Final simplification72.5%
(FPCore (x y) :precision binary64 (fma (* (* y y) (* (* y y) (* x (fma (* x (* y y)) 0.16666666666666666 0.5)))) x (fma x (* y y) 1.0)))
double code(double x, double y) {
return fma(((y * y) * ((y * y) * (x * fma((x * (y * y)), 0.16666666666666666, 0.5)))), x, fma(x, (y * y), 1.0));
}
function code(x, y) return fma(Float64(Float64(y * y) * Float64(Float64(y * y) * Float64(x * fma(Float64(x * Float64(y * y)), 0.16666666666666666, 0.5)))), x, fma(x, Float64(y * y), 1.0)) end
code[x_, y_] := N[(N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x + N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\left(y \cdot y\right) \cdot \left(\left(y \cdot y\right) \cdot \left(x \cdot \mathsf{fma}\left(x \cdot \left(y \cdot y\right), 0.16666666666666666, 0.5\right)\right)\right), x, \mathsf{fma}\left(x, y \cdot y, 1\right)\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
Simplified71.9%
distribute-lft-inN/A
*-rgt-identityN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
Applied egg-rr72.6%
Final simplification72.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* x (* y y))))
(if (<= (* y (* x y)) 1e+27)
(fma t_0 (fma x (* (* y y) 0.5) 1.0) 1.0)
(* y (* 0.16666666666666666 (* x (* x t_0)))))))
double code(double x, double y) {
double t_0 = x * (y * y);
double tmp;
if ((y * (x * y)) <= 1e+27) {
tmp = fma(t_0, fma(x, ((y * y) * 0.5), 1.0), 1.0);
} else {
tmp = y * (0.16666666666666666 * (x * (x * t_0)));
}
return tmp;
}
function code(x, y) t_0 = Float64(x * Float64(y * y)) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 1e+27) tmp = fma(t_0, fma(x, Float64(Float64(y * y) * 0.5), 1.0), 1.0); else tmp = Float64(y * Float64(0.16666666666666666 * Float64(x * Float64(x * t_0)))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 1e+27], N[(t$95$0 * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(y * N[(0.16666666666666666 * N[(x * N[(x * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(y \cdot y\right)\\
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 10^{+27}:\\
\;\;\;\;\mathsf{fma}\left(t\_0, \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.5, 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(0.16666666666666666 \cdot \left(x \cdot \left(x \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 1e27Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified64.8%
if 1e27 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied egg-rr40.8%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
cube-multN/A
unpow2N/A
associate-*r*N/A
distribute-rgt-outN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6442.8
Simplified42.8%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
unpow3N/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
unpow2N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.8
Simplified38.8%
Final simplification57.3%
(FPCore (x y) :precision binary64 (let* ((t_0 (* x (* y y)))) (fma (fma (* y y) (* x (fma t_0 0.16666666666666666 0.5)) 1.0) t_0 1.0)))
double code(double x, double y) {
double t_0 = x * (y * y);
return fma(fma((y * y), (x * fma(t_0, 0.16666666666666666, 0.5)), 1.0), t_0, 1.0);
}
function code(x, y) t_0 = Float64(x * Float64(y * y)) return fma(fma(Float64(y * y), Float64(x * fma(t_0, 0.16666666666666666, 0.5)), 1.0), t_0, 1.0) end
code[x_, y_] := Block[{t$95$0 = N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(y * y), $MachinePrecision] * N[(x * N[(t$95$0 * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0 + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(y \cdot y\right)\\
\mathsf{fma}\left(\mathsf{fma}\left(y \cdot y, x \cdot \mathsf{fma}\left(t\_0, 0.16666666666666666, 0.5\right), 1\right), t\_0, 1\right)
\end{array}
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
Simplified71.9%
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
associate-*l*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.3
Applied egg-rr72.3%
(FPCore (x y) :precision binary64 (fma (* (* y y) (* (* y y) (* x (fma (* x (* y y)) 0.16666666666666666 0.5)))) x 1.0))
double code(double x, double y) {
return fma(((y * y) * ((y * y) * (x * fma((x * (y * y)), 0.16666666666666666, 0.5)))), x, 1.0);
}
function code(x, y) return fma(Float64(Float64(y * y) * Float64(Float64(y * y) * Float64(x * fma(Float64(x * Float64(y * y)), 0.16666666666666666, 0.5)))), x, 1.0) end
code[x_, y_] := N[(N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * 0.16666666666666666 + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\left(y \cdot y\right) \cdot \left(\left(y \cdot y\right) \cdot \left(x \cdot \mathsf{fma}\left(x \cdot \left(y \cdot y\right), 0.16666666666666666, 0.5\right)\right)\right), x, 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
Simplified71.9%
distribute-lft-inN/A
*-rgt-identityN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
Applied egg-rr72.6%
Taylor expanded in x around 0
Simplified72.2%
Final simplification72.2%
(FPCore (x y) :precision binary64 (fma (* x (* y y)) (* x (* x (fma 0.16666666666666666 (* (* y y) (* y y)) 0.0))) 1.0))
double code(double x, double y) {
return fma((x * (y * y)), (x * (x * fma(0.16666666666666666, ((y * y) * (y * y)), 0.0))), 1.0);
}
function code(x, y) return fma(Float64(x * Float64(y * y)), Float64(x * Float64(x * fma(0.16666666666666666, Float64(Float64(y * y) * Float64(y * y)), 0.0))), 1.0) end
code[x_, y_] := N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(x * N[(x * N[(0.16666666666666666 * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision] + 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x \cdot \left(y \cdot y\right), x \cdot \left(x \cdot \mathsf{fma}\left(0.16666666666666666, \left(y \cdot y\right) \cdot \left(y \cdot y\right), 0\right)\right), 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
Simplified71.9%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-rgt-identityN/A
accelerator-lowering-fma.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6471.9
Simplified71.9%
(FPCore (x y) :precision binary64 (if (<= y 2.65e+88) (fma (* (* x y) (fma (* x y) (* y 0.5) 1.0)) y 1.0) (* x (* 0.5 (* x (* (* y y) (* y y)))))))
double code(double x, double y) {
double tmp;
if (y <= 2.65e+88) {
tmp = fma(((x * y) * fma((x * y), (y * 0.5), 1.0)), y, 1.0);
} else {
tmp = x * (0.5 * (x * ((y * y) * (y * y))));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.65e+88) tmp = fma(Float64(Float64(x * y) * fma(Float64(x * y), Float64(y * 0.5), 1.0)), y, 1.0); else tmp = Float64(x * Float64(0.5 * Float64(x * Float64(Float64(y * y) * Float64(y * y))))); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.65e+88], N[(N[(N[(x * y), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] * N[(y * 0.5), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(x * N[(0.5 * N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.65 \cdot 10^{+88}:\\
\;\;\;\;\mathsf{fma}\left(\left(x \cdot y\right) \cdot \mathsf{fma}\left(x \cdot y, y \cdot 0.5, 1\right), y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(0.5 \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot \left(y \cdot y\right)\right)\right)\right)\\
\end{array}
\end{array}
if y < 2.64999999999999994e88Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified73.0%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.9
Applied egg-rr73.9%
if 2.64999999999999994e88 < y Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Simplified53.0%
Taylor expanded in x around inf
*-commutativeN/A
associate-*r*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
pow-sqrN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6459.0
Simplified59.0%
Final simplification71.1%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 1e+27) (fma (* x y) y 1.0) (* 0.5 (* x (* x (* y y))))))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 1e+27) {
tmp = fma((x * y), y, 1.0);
} else {
tmp = 0.5 * (x * (x * (y * y)));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 1e+27) tmp = fma(Float64(x * y), y, 1.0); else tmp = Float64(0.5 * Float64(x * Float64(x * Float64(y * y)))); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 1e+27], N[(N[(x * y), $MachinePrecision] * y + 1.0), $MachinePrecision], N[(0.5 * N[(x * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 10^{+27}:\\
\;\;\;\;\mathsf{fma}\left(x \cdot y, y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \left(x \cdot \left(y \cdot y\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 1e27Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6464.6
Simplified64.6%
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6464.7
Applied egg-rr64.7%
if 1e27 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied egg-rr40.8%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
cube-multN/A
unpow2N/A
associate-*r*N/A
distribute-rgt-outN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6442.8
Simplified42.8%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6484.5
Simplified84.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6484.5
Simplified84.5%
Final simplification70.3%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 0.5) 1.0 (* x (* y y))))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 0.5) {
tmp = 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 ((y * (x * y)) <= 0.5d0) then
tmp = 1.0d0
else
tmp = x * (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 0.5) {
tmp = 1.0;
} else {
tmp = x * (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if (y * (x * y)) <= 0.5: tmp = 1.0 else: tmp = x * (y * y) return tmp
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 0.5) tmp = 1.0; else tmp = Float64(x * Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y * (x * y)) <= 0.5) tmp = 1.0; else tmp = x * (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 0.5], 1.0, N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 0.5:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot y\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 0.5Initial program 100.0%
Applied egg-rr67.4%
if 0.5 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6466.9
Simplified66.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.9
Simplified66.9%
Final simplification67.3%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 5e+47) 1.0 (* x y)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 5e+47) {
tmp = 1.0;
} 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 * (x * y)) <= 5d+47) then
tmp = 1.0d0
else
tmp = x * y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 5e+47) {
tmp = 1.0;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y): tmp = 0 if (y * (x * y)) <= 5e+47: tmp = 1.0 else: tmp = x * y return tmp
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 5e+47) tmp = 1.0; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y * (x * y)) <= 5e+47) tmp = 1.0; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 5e+47], 1.0, N[(x * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 5 \cdot 10^{+47}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 5.00000000000000022e47Initial program 100.0%
Applied egg-rr64.3%
if 5.00000000000000022e47 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied egg-rr41.3%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f6417.0
Simplified17.0%
Taylor expanded in x around inf
*-lowering-*.f6416.9
Simplified16.9%
Final simplification51.0%
(FPCore (x y) :precision binary64 (fma x (* y y) 1.0))
double code(double x, double y) {
return fma(x, (y * y), 1.0);
}
function code(x, y) return fma(x, Float64(y * y), 1.0) end
code[x_, y_] := N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y \cdot y, 1\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6467.3
Simplified67.3%
(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 100.0%
Applied egg-rr47.1%
herbie shell --seed 2024195
(FPCore (x y)
:name "Data.Random.Distribution.Normal:normalF from random-fu-0.2.6.2"
:precision binary64
(exp (* (* x y) y)))