
(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 15 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
(let* ((t_0 (exp (* y (* x y)))))
(if (<= t_0 0.0)
(* (* y (* x x)) (* y 0.5))
(if (<= t_0 2.0)
(fma x (* y y) 1.0)
(* x (* x (* 0.5 (* (* y y) (* y y)))))))))
double code(double x, double y) {
double t_0 = exp((y * (x * y)));
double tmp;
if (t_0 <= 0.0) {
tmp = (y * (x * x)) * (y * 0.5);
} else if (t_0 <= 2.0) {
tmp = fma(x, (y * y), 1.0);
} else {
tmp = x * (x * (0.5 * ((y * y) * (y * y))));
}
return tmp;
}
function code(x, y) t_0 = exp(Float64(y * Float64(x * y))) tmp = 0.0 if (t_0 <= 0.0) tmp = Float64(Float64(y * Float64(x * x)) * Float64(y * 0.5)); elseif (t_0 <= 2.0) tmp = fma(x, Float64(y * y), 1.0); else tmp = Float64(x * Float64(x * Float64(0.5 * Float64(Float64(y * y) * Float64(y * y))))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, 0.0], N[(N[(y * N[(x * x), $MachinePrecision]), $MachinePrecision] * N[(y * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2.0], N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * N[(0.5 * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{y \cdot \left(x \cdot y\right)}\\
\mathbf{if}\;t\_0 \leq 0:\\
\;\;\;\;\left(y \cdot \left(x \cdot x\right)\right) \cdot \left(y \cdot 0.5\right)\\
\mathbf{elif}\;t\_0 \leq 2:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(x \cdot \left(0.5 \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)) < 0.0Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.7
Applied rewrites1.7%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.8
Applied rewrites1.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6416.2
Applied rewrites16.2%
if 0.0 < (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6499.5
Applied rewrites99.5%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Applied rewrites84.7%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-evalN/A
pow-sqrN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6486.3
Applied rewrites86.3%
Final simplification74.5%
(FPCore (x y) :precision binary64 (if (<= (exp (* y (* x y))) 2.0) 1.0 (* x (* y y))))
double code(double x, double y) {
double tmp;
if (exp((y * (x * y))) <= 2.0) {
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 (exp((y * (x * y))) <= 2.0d0) 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 (Math.exp((y * (x * y))) <= 2.0) {
tmp = 1.0;
} else {
tmp = x * (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if math.exp((y * (x * y))) <= 2.0: tmp = 1.0 else: tmp = x * (y * y) return tmp
function code(x, y) tmp = 0.0 if (exp(Float64(y * Float64(x * y))) <= 2.0) tmp = 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 * (x * y))) <= 2.0) tmp = 1.0; else tmp = x * (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 2.0], 1.0, N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(x \cdot y\right)} \leq 2:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot y\right)\\
\end{array}
\end{array}
if (exp.f64 (*.f64 (*.f64 x y) y)) < 2Initial program 100.0%
Applied rewrites66.4%
if 2 < (exp.f64 (*.f64 (*.f64 x y) y)) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6469.3
Applied rewrites69.3%
Taylor expanded in x around inf
lower-*.f64N/A
unpow2N/A
lower-*.f6469.3
Applied rewrites69.3%
Final simplification67.1%
(FPCore (x y)
:precision binary64
(if (<= (* y (* x y)) -4e+14)
(exp (* x y))
(fma
(* y y)
(fma (* x (* x (* y y))) (fma x (* (* y y) 0.16666666666666666) 0.5) x)
1.0)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= -4e+14) {
tmp = exp((x * y));
} else {
tmp = fma((y * y), fma((x * (x * (y * y))), fma(x, ((y * y) * 0.16666666666666666), 0.5), x), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= -4e+14) tmp = exp(Float64(x * y)); else tmp = fma(Float64(y * y), fma(Float64(x * Float64(x * Float64(y * y))), fma(x, Float64(Float64(y * y) * 0.16666666666666666), 0.5), x), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], -4e+14], N[Exp[N[(x * y), $MachinePrecision]], $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(N[(x * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] + 0.5), $MachinePrecision] + x), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq -4 \cdot 10^{+14}:\\
\;\;\;\;e^{x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(x \cdot \left(x \cdot \left(y \cdot y\right)\right), \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.16666666666666666, 0.5\right), x\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
if -4e14 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
Applied rewrites96.9%
Final simplification81.7%
(FPCore (x y)
:precision binary64
(if (<= (* y (* x y)) -4e+14)
(exp x)
(fma
(* y y)
(fma (* x (* x (* y y))) (fma x (* (* y y) 0.16666666666666666) 0.5) x)
1.0)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= -4e+14) {
tmp = exp(x);
} else {
tmp = fma((y * y), fma((x * (x * (y * y))), fma(x, ((y * y) * 0.16666666666666666), 0.5), x), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= -4e+14) tmp = exp(x); else tmp = fma(Float64(y * y), fma(Float64(x * Float64(x * Float64(y * y))), fma(x, Float64(Float64(y * y) * 0.16666666666666666), 0.5), x), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], -4e+14], N[Exp[x], $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(N[(x * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] + 0.5), $MachinePrecision] + x), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq -4 \cdot 10^{+14}:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(x \cdot \left(x \cdot \left(y \cdot y\right)\right), \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.16666666666666666, 0.5\right), x\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites60.1%
if -4e14 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
Applied rewrites96.9%
Final simplification87.1%
(FPCore (x y)
:precision binary64
(if (<= (* y (* x y)) -4e+14)
(* y (* y (* y (* x (* 0.16666666666666666 (* x x))))))
(fma
(* y y)
(fma (* x (* x (* y y))) (fma x (* (* y y) 0.16666666666666666) 0.5) x)
1.0)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= -4e+14) {
tmp = y * (y * (y * (x * (0.16666666666666666 * (x * x)))));
} else {
tmp = fma((y * y), fma((x * (x * (y * y))), fma(x, ((y * y) * 0.16666666666666666), 0.5), x), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= -4e+14) tmp = Float64(y * Float64(y * Float64(y * Float64(x * Float64(0.16666666666666666 * Float64(x * x)))))); else tmp = fma(Float64(y * y), fma(Float64(x * Float64(x * Float64(y * y))), fma(x, Float64(Float64(y * y) * 0.16666666666666666), 0.5), x), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], -4e+14], N[(y * N[(y * N[(y * N[(x * N[(0.16666666666666666 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(N[(x * N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * N[(N[(y * y), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] + 0.5), $MachinePrecision] + x), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq -4 \cdot 10^{+14}:\\
\;\;\;\;y \cdot \left(y \cdot \left(y \cdot \left(x \cdot \left(0.16666666666666666 \cdot \left(x \cdot x\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(x \cdot \left(x \cdot \left(y \cdot y\right)\right), \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.16666666666666666, 0.5\right), x\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.6
Applied rewrites1.6%
Taylor expanded in y around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6427.7
Applied rewrites27.7%
if -4e14 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
Applied rewrites96.9%
Final simplification78.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* y (* x y))))
(if (<= t_0 -4e+14)
(* y (* y (* y (* x (* 0.16666666666666666 (* x x))))))
(if (<= t_0 1e-14)
(fma x (* y y) 1.0)
(* x (* x (* 0.5 (* (* y y) (* y y)))))))))
double code(double x, double y) {
double t_0 = y * (x * y);
double tmp;
if (t_0 <= -4e+14) {
tmp = y * (y * (y * (x * (0.16666666666666666 * (x * x)))));
} else if (t_0 <= 1e-14) {
tmp = fma(x, (y * y), 1.0);
} else {
tmp = x * (x * (0.5 * ((y * y) * (y * y))));
}
return tmp;
}
function code(x, y) t_0 = Float64(y * Float64(x * y)) tmp = 0.0 if (t_0 <= -4e+14) tmp = Float64(y * Float64(y * Float64(y * Float64(x * Float64(0.16666666666666666 * Float64(x * x)))))); elseif (t_0 <= 1e-14) tmp = fma(x, Float64(y * y), 1.0); else tmp = Float64(x * Float64(x * Float64(0.5 * Float64(Float64(y * y) * Float64(y * y))))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -4e+14], N[(y * N[(y * N[(y * N[(x * N[(0.16666666666666666 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 1e-14], N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * N[(0.5 * N[(N[(y * y), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y \cdot \left(x \cdot y\right)\\
\mathbf{if}\;t\_0 \leq -4 \cdot 10^{+14}:\\
\;\;\;\;y \cdot \left(y \cdot \left(y \cdot \left(x \cdot \left(0.16666666666666666 \cdot \left(x \cdot x\right)\right)\right)\right)\right)\\
\mathbf{elif}\;t\_0 \leq 10^{-14}:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(x \cdot \left(0.5 \cdot \left(\left(y \cdot y\right) \cdot \left(y \cdot y\right)\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.6
Applied rewrites1.6%
Taylor expanded in y around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6427.7
Applied rewrites27.7%
if -4e14 < (*.f64 (*.f64 x y) y) < 9.99999999999999999e-15Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6499.5
Applied rewrites99.5%
if 9.99999999999999999e-15 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Applied rewrites84.7%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-evalN/A
pow-sqrN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6486.3
Applied rewrites86.3%
Final simplification77.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* y (* x y))))
(if (<= t_0 -4e+14)
(* (* y (* x x)) (* y 0.5))
(if (<= t_0 4e+16)
(fma x (* y y) 1.0)
(fma x (fma x (* (* y y) 0.5) y) 1.0)))))
double code(double x, double y) {
double t_0 = y * (x * y);
double tmp;
if (t_0 <= -4e+14) {
tmp = (y * (x * x)) * (y * 0.5);
} else if (t_0 <= 4e+16) {
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) t_0 = Float64(y * Float64(x * y)) tmp = 0.0 if (t_0 <= -4e+14) tmp = Float64(Float64(y * Float64(x * x)) * Float64(y * 0.5)); elseif (t_0 <= 4e+16) tmp = fma(x, Float64(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_] := Block[{t$95$0 = N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -4e+14], N[(N[(y * N[(x * x), $MachinePrecision]), $MachinePrecision] * N[(y * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 4e+16], N[(x * N[(y * y), $MachinePrecision] + 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}
t_0 := y \cdot \left(x \cdot y\right)\\
\mathbf{if}\;t\_0 \leq -4 \cdot 10^{+14}:\\
\;\;\;\;\left(y \cdot \left(x \cdot x\right)\right) \cdot \left(y \cdot 0.5\right)\\
\mathbf{elif}\;t\_0 \leq 4 \cdot 10^{+16}:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot 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 (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.7
Applied rewrites1.7%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.8
Applied rewrites1.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6416.2
Applied rewrites16.2%
if -4e14 < (*.f64 (*.f64 x y) y) < 4e16Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6498.8
Applied rewrites98.8%
if 4e16 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied rewrites44.7%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.6
Applied rewrites82.6%
Final simplification73.4%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* y (* x y))))
(if (<= t_0 -4e+14)
(* (* y (* x x)) (* y 0.5))
(if (<= t_0 4e+16) (fma x (* y y) 1.0) (* x (* x (* (* y y) 0.5)))))))
double code(double x, double y) {
double t_0 = y * (x * y);
double tmp;
if (t_0 <= -4e+14) {
tmp = (y * (x * x)) * (y * 0.5);
} else if (t_0 <= 4e+16) {
tmp = fma(x, (y * y), 1.0);
} else {
tmp = x * (x * ((y * y) * 0.5));
}
return tmp;
}
function code(x, y) t_0 = Float64(y * Float64(x * y)) tmp = 0.0 if (t_0 <= -4e+14) tmp = Float64(Float64(y * Float64(x * x)) * Float64(y * 0.5)); elseif (t_0 <= 4e+16) tmp = fma(x, Float64(y * y), 1.0); else tmp = Float64(x * Float64(x * Float64(Float64(y * y) * 0.5))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -4e+14], N[(N[(y * N[(x * x), $MachinePrecision]), $MachinePrecision] * N[(y * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 4e+16], N[(x * N[(y * y), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y \cdot \left(x \cdot y\right)\\
\mathbf{if}\;t\_0 \leq -4 \cdot 10^{+14}:\\
\;\;\;\;\left(y \cdot \left(x \cdot x\right)\right) \cdot \left(y \cdot 0.5\right)\\
\mathbf{elif}\;t\_0 \leq 4 \cdot 10^{+16}:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot y, 1\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot 0.5\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.7
Applied rewrites1.7%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.8
Applied rewrites1.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6416.2
Applied rewrites16.2%
if -4e14 < (*.f64 (*.f64 x y) y) < 4e16Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6498.8
Applied rewrites98.8%
if 4e16 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied rewrites44.7%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.6
Applied rewrites82.6%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.6
Applied rewrites82.6%
Final simplification73.4%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) -4e+14) (* y (* y (* y (* x (* 0.16666666666666666 (* x x)))))) (fma (* y y) (fma x (* (* x (* y y)) 0.5) x) 1.0)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= -4e+14) {
tmp = y * (y * (y * (x * (0.16666666666666666 * (x * x)))));
} else {
tmp = fma((y * y), fma(x, ((x * (y * y)) * 0.5), x), 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= -4e+14) tmp = Float64(y * Float64(y * Float64(y * Float64(x * Float64(0.16666666666666666 * Float64(x * x)))))); else tmp = fma(Float64(y * y), fma(x, Float64(Float64(x * Float64(y * y)) * 0.5), x), 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], -4e+14], N[(y * N[(y * N[(y * N[(x * N[(0.16666666666666666 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * 0.5), $MachinePrecision] + x), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq -4 \cdot 10^{+14}:\\
\;\;\;\;y \cdot \left(y \cdot \left(y \cdot \left(x \cdot \left(0.16666666666666666 \cdot \left(x \cdot x\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(x, \left(x \cdot \left(y \cdot y\right)\right) \cdot 0.5, x\right), 1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < -4e14Initial program 100.0%
Applied rewrites39.4%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f641.6
Applied rewrites1.6%
Taylor expanded in y around inf
associate-*r*N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6427.7
Applied rewrites27.7%
if -4e14 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
Applied rewrites95.3%
Final simplification77.3%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 4e+16) 1.0 (* x (* x (* (* y y) 0.5)))))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 4e+16) {
tmp = 1.0;
} else {
tmp = x * (x * ((y * y) * 0.5));
}
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)) <= 4d+16) then
tmp = 1.0d0
else
tmp = x * (x * ((y * y) * 0.5d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 4e+16) {
tmp = 1.0;
} else {
tmp = x * (x * ((y * y) * 0.5));
}
return tmp;
}
def code(x, y): tmp = 0 if (y * (x * y)) <= 4e+16: tmp = 1.0 else: tmp = x * (x * ((y * y) * 0.5)) return tmp
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 4e+16) tmp = 1.0; else tmp = Float64(x * Float64(x * Float64(Float64(y * y) * 0.5))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y * (x * y)) <= 4e+16) tmp = 1.0; else tmp = x * (x * ((y * y) * 0.5)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 4e+16], 1.0, N[(x * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 4 \cdot 10^{+16}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot 0.5\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 4e16Initial program 100.0%
Applied rewrites66.1%
if 4e16 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied rewrites44.7%
Taylor expanded in x around 0
+-commutativeN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.6
Applied rewrites82.6%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.6
Applied rewrites82.6%
Final simplification69.7%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 1e-14) 1.0 (fma x y 1.0)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 1e-14) {
tmp = 1.0;
} else {
tmp = fma(x, y, 1.0);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 1e-14) tmp = 1.0; else tmp = fma(x, y, 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 1e-14], 1.0, N[(x * y + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 10^{-14}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, y, 1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 9.99999999999999999e-15Initial program 100.0%
Applied rewrites66.4%
if 9.99999999999999999e-15 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied rewrites43.9%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f6414.5
Applied rewrites14.5%
Final simplification55.1%
(FPCore (x y) :precision binary64 (if (<= (* y (* x y)) 4e+16) 1.0 (* x y)))
double code(double x, double y) {
double tmp;
if ((y * (x * y)) <= 4e+16) {
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)) <= 4d+16) 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)) <= 4e+16) {
tmp = 1.0;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y): tmp = 0 if (y * (x * y)) <= 4e+16: tmp = 1.0 else: tmp = x * y return tmp
function code(x, y) tmp = 0.0 if (Float64(y * Float64(x * y)) <= 4e+16) 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)) <= 4e+16) tmp = 1.0; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision], 4e+16], 1.0, N[(x * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(x \cdot y\right) \leq 4 \cdot 10^{+16}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 (*.f64 x y) y) < 4e16Initial program 100.0%
Applied rewrites66.1%
if 4e16 < (*.f64 (*.f64 x y) y) Initial program 100.0%
Applied rewrites44.7%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f6414.7
Applied rewrites14.7%
Taylor expanded in x around inf
lower-*.f6414.6
Applied rewrites14.6%
Final simplification55.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
lower-fma.f64N/A
unpow2N/A
lower-*.f6467.0
Applied rewrites67.0%
(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 rewrites52.6%
herbie shell --seed 2024212
(FPCore (x y)
:name "Data.Random.Distribution.Normal:normalF from random-fu-0.2.6.2"
:precision binary64
(exp (* (* x y) y)))