
(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 16 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 (* (exp (* y y)) x))
double code(double x, double y) {
return exp((y * y)) * x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp((y * y)) * x
end function
public static double code(double x, double y) {
return Math.exp((y * y)) * x;
}
def code(x, y): return math.exp((y * y)) * x
function code(x, y) return Float64(exp(Float64(y * y)) * x) end
function tmp = code(x, y) tmp = exp((y * y)) * x; end
code[x_, y_] := N[(N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
\\
e^{y \cdot y} \cdot x
\end{array}
Initial program 100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 5.0) (* 1.0 x) (* (* y y) x)))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} else {
tmp = (y * y) * x;
}
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)) <= 5.0d0) then
tmp = 1.0d0 * x
else
tmp = (y * y) * x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (Math.exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} else {
tmp = (y * y) * x;
}
return tmp;
}
def code(x, y): tmp = 0 if math.exp((y * y)) <= 5.0: tmp = 1.0 * x else: tmp = (y * y) * x return tmp
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 5.0) tmp = Float64(1.0 * x); else tmp = Float64(Float64(y * y) * x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (exp((y * y)) <= 5.0) tmp = 1.0 * x; else tmp = (y * y) * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 5.0], N[(1.0 * x), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 5:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot y\right) \cdot x\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 5Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites98.5%
if 5 < (exp.f64 (*.f64 y y)) Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6462.2
Applied rewrites62.2%
Taylor expanded in y around inf
Applied rewrites62.2%
Final simplification81.3%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 5.0) (* 1.0 x) (* (* y x) y)))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} else {
tmp = (y * x) * 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)) <= 5.0d0) then
tmp = 1.0d0 * x
else
tmp = (y * x) * y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (Math.exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} else {
tmp = (y * x) * y;
}
return tmp;
}
def code(x, y): tmp = 0 if math.exp((y * y)) <= 5.0: tmp = 1.0 * x else: tmp = (y * x) * y return tmp
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 5.0) tmp = Float64(1.0 * x); else tmp = Float64(Float64(y * x) * y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (exp((y * y)) <= 5.0) tmp = 1.0 * x; else tmp = (y * x) * y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 5.0], N[(1.0 * x), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 5:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot y\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 5Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites98.5%
if 5 < (exp.f64 (*.f64 y y)) Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6462.2
Applied rewrites62.2%
Taylor expanded in y around inf
Applied rewrites62.2%
Applied rewrites52.9%
Final simplification76.9%
(FPCore (x y) :precision binary64 (if (<= (exp (* y y)) 5.0) (* 1.0 x) (* y x)))
double code(double x, double y) {
double tmp;
if (exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} 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 (exp((y * y)) <= 5.0d0) then
tmp = 1.0d0 * x
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (Math.exp((y * y)) <= 5.0) {
tmp = 1.0 * x;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y): tmp = 0 if math.exp((y * y)) <= 5.0: tmp = 1.0 * x else: tmp = y * x return tmp
function code(x, y) tmp = 0.0 if (exp(Float64(y * y)) <= 5.0) tmp = Float64(1.0 * x); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (exp((y * y)) <= 5.0) tmp = 1.0 * x; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[Exp[N[(y * y), $MachinePrecision]], $MachinePrecision], 5.0], N[(1.0 * x), $MachinePrecision], N[(y * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot y} \leq 5:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if (exp.f64 (*.f64 y y)) < 5Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites98.5%
if 5 < (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.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6412.8
Applied rewrites12.8%
Taylor expanded in y around inf
Applied rewrites12.8%
Final simplification58.0%
(FPCore (x y) :precision binary64 (* (exp y) x))
double code(double x, double y) {
return exp(y) * x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp(y) * x
end function
public static double code(double x, double y) {
return Math.exp(y) * x;
}
def code(x, y): return math.exp(y) * x
function code(x, y) return Float64(exp(y) * x) end
function tmp = code(x, y) tmp = exp(y) * x; end
code[x_, y_] := N[(N[Exp[y], $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
\\
e^{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 rewrites76.4%
Final simplification76.4%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* (* (fma 0.16666666666666666 y 0.5) y) y)))
(if (<= (* y y) 5e+102)
(fma (* (fma 0.5 (* (* y y) x) x) y) y x)
(if (<= (* y y) 5e+188)
(* (/ (- (* t_0 t_0) (* y y)) (- t_0 y)) x)
(* (* (* (* 0.16666666666666666 y) y) y) x)))))
double code(double x, double y) {
double t_0 = (fma(0.16666666666666666, y, 0.5) * y) * y;
double tmp;
if ((y * y) <= 5e+102) {
tmp = fma((fma(0.5, ((y * y) * x), x) * y), y, x);
} else if ((y * y) <= 5e+188) {
tmp = (((t_0 * t_0) - (y * y)) / (t_0 - y)) * x;
} else {
tmp = (((0.16666666666666666 * y) * y) * y) * x;
}
return tmp;
}
function code(x, y) t_0 = Float64(Float64(fma(0.16666666666666666, y, 0.5) * y) * y) tmp = 0.0 if (Float64(y * y) <= 5e+102) tmp = fma(Float64(fma(0.5, Float64(Float64(y * y) * x), x) * y), y, x); elseif (Float64(y * y) <= 5e+188) tmp = Float64(Float64(Float64(Float64(t_0 * t_0) - Float64(y * y)) / Float64(t_0 - y)) * x); else tmp = Float64(Float64(Float64(Float64(0.16666666666666666 * y) * y) * y) * x); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(N[(N[(0.16666666666666666 * y + 0.5), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[N[(y * y), $MachinePrecision], 5e+102], N[(N[(N[(0.5 * N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision] + x), $MachinePrecision] * y), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[N[(y * y), $MachinePrecision], 5e+188], N[(N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(y * y), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(N[(0.16666666666666666 * y), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\mathsf{fma}\left(0.16666666666666666, y, 0.5\right) \cdot y\right) \cdot y\\
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{+102}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.5, \left(y \cdot y\right) \cdot x, x\right) \cdot y, y, x\right)\\
\mathbf{elif}\;y \cdot y \leq 5 \cdot 10^{+188}:\\
\;\;\;\;\frac{t\_0 \cdot t\_0 - y \cdot y}{t\_0 - y} \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(0.16666666666666666 \cdot y\right) \cdot y\right) \cdot y\right) \cdot x\\
\end{array}
\end{array}
if (*.f64 y y) < 5e102Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6487.8
Applied rewrites87.8%
Taylor expanded in y around inf
Applied rewrites4.8%
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-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.4
Applied rewrites90.4%
Applied rewrites90.4%
if 5e102 < (*.f64 y y) < 5.0000000000000001e188Initial 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 rewrites78.6%
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.f6437.2
Applied rewrites37.2%
Taylor expanded in y around inf
Applied rewrites37.2%
Applied rewrites78.3%
if 5.0000000000000001e188 < (*.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 rewrites49.6%
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.f6448.8
Applied rewrites48.8%
Taylor expanded in y around inf
Applied rewrites48.8%
Taylor expanded in y around inf
Applied rewrites48.8%
Final simplification76.3%
(FPCore (x y)
:precision binary64
(if (<= (* y y) 2e+152)
(fma (* (fma 0.5 (* (* y y) x) x) y) y x)
(*
(/
(* (fma 0.027777777777777776 (* y y) -0.25) (* y y))
(fma 0.16666666666666666 y -0.5))
x)))
double code(double x, double y) {
double tmp;
if ((y * y) <= 2e+152) {
tmp = fma((fma(0.5, ((y * y) * x), x) * y), y, x);
} else {
tmp = ((fma(0.027777777777777776, (y * y), -0.25) * (y * y)) / fma(0.16666666666666666, y, -0.5)) * x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 2e+152) tmp = fma(Float64(fma(0.5, Float64(Float64(y * y) * x), x) * y), y, x); else tmp = Float64(Float64(Float64(fma(0.027777777777777776, Float64(y * y), -0.25) * Float64(y * y)) / fma(0.16666666666666666, y, -0.5)) * x); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 2e+152], N[(N[(N[(0.5 * N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision] + x), $MachinePrecision] * y), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(N[(N[(0.027777777777777776 * N[(y * y), $MachinePrecision] + -0.25), $MachinePrecision] * N[(y * y), $MachinePrecision]), $MachinePrecision] / N[(0.16666666666666666 * y + -0.5), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 2 \cdot 10^{+152}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.5, \left(y \cdot y\right) \cdot x, x\right) \cdot y, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(0.027777777777777776, y \cdot y, -0.25\right) \cdot \left(y \cdot y\right)}{\mathsf{fma}\left(0.16666666666666666, y, -0.5\right)} \cdot x\\
\end{array}
\end{array}
if (*.f64 y y) < 2.0000000000000001e152Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6483.7
Applied rewrites83.7%
Taylor expanded in y around inf
Applied rewrites7.6%
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-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6487.2
Applied rewrites87.2%
Applied rewrites87.2%
if 2.0000000000000001e152 < (*.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 rewrites54.7%
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.f6448.6
Applied rewrites48.6%
Taylor expanded in y around inf
Applied rewrites48.6%
Applied rewrites53.9%
Final simplification75.6%
(FPCore (x y) :precision binary64 (if (<= (* y y) 1.0) (fma (* y x) y x) (* (* (* (fma 0.16666666666666666 y 0.5) y) y) x)))
double code(double x, double y) {
double tmp;
if ((y * y) <= 1.0) {
tmp = fma((y * x), y, x);
} else {
tmp = ((fma(0.16666666666666666, y, 0.5) * y) * y) * x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 1.0) tmp = fma(Float64(y * x), y, x); else tmp = Float64(Float64(Float64(fma(0.16666666666666666, y, 0.5) * y) * y) * x); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 1.0], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(N[(N[(0.16666666666666666 * y + 0.5), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 1:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(0.16666666666666666, y, 0.5\right) \cdot y\right) \cdot y\right) \cdot x\\
\end{array}
\end{array}
if (*.f64 y y) < 1Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6498.9
Applied rewrites98.9%
Applied rewrites98.9%
if 1 < (*.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.8%
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.f6440.4
Applied rewrites40.4%
Taylor expanded in y around inf
Applied rewrites40.4%
Final simplification71.2%
(FPCore (x y) :precision binary64 (if (<= (* y y) 1.0) (fma (* y x) y x) (* (* (* (* 0.16666666666666666 y) y) y) x)))
double code(double x, double y) {
double tmp;
if ((y * y) <= 1.0) {
tmp = fma((y * x), y, x);
} else {
tmp = (((0.16666666666666666 * y) * y) * y) * x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 1.0) tmp = fma(Float64(y * x), y, x); else tmp = Float64(Float64(Float64(Float64(0.16666666666666666 * y) * y) * y) * x); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 1.0], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(N[(N[(0.16666666666666666 * y), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 1:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(0.16666666666666666 \cdot y\right) \cdot y\right) \cdot y\right) \cdot x\\
\end{array}
\end{array}
if (*.f64 y y) < 1Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6498.9
Applied rewrites98.9%
Applied rewrites98.9%
if 1 < (*.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.8%
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.f6440.4
Applied rewrites40.4%
Taylor expanded in y around inf
Applied rewrites40.4%
Taylor expanded in y around inf
Applied rewrites40.4%
Final simplification71.2%
(FPCore (x y) :precision binary64 (fma (* (fma 0.5 (* (* y y) x) x) y) y x))
double code(double x, double y) {
return fma((fma(0.5, ((y * y) * x), x) * y), y, x);
}
function code(x, y) return fma(Float64(fma(0.5, Float64(Float64(y * y) * x), x) * y), y, x) end
code[x_, y_] := N[(N[(N[(0.5 * N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision] + x), $MachinePrecision] * y), $MachinePrecision] * y + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(0.5, \left(y \cdot y\right) \cdot x, x\right) \cdot y, y, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6481.5
Applied rewrites81.5%
Taylor expanded in y around inf
Applied rewrites31.9%
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-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6489.1
Applied rewrites89.1%
Applied rewrites89.1%
(FPCore (x y) :precision binary64 (fma (* (* (* y y) x) 0.5) (* y y) x))
double code(double x, double y) {
return fma((((y * y) * x) * 0.5), (y * y), x);
}
function code(x, y) return fma(Float64(Float64(Float64(y * y) * x) * 0.5), Float64(y * y), x) end
code[x_, y_] := N[(N[(N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision] * 0.5), $MachinePrecision] * N[(y * y), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\left(\left(y \cdot y\right) \cdot x\right) \cdot 0.5, y \cdot y, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6481.5
Applied rewrites81.5%
Taylor expanded in y around inf
Applied rewrites31.9%
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-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6489.1
Applied rewrites89.1%
Taylor expanded in y around inf
Applied rewrites88.9%
Final simplification88.9%
(FPCore (x y) :precision binary64 (if (<= (* y y) 5e+59) (fma (* y x) y x) (* (* y y) x)))
double code(double x, double y) {
double tmp;
if ((y * y) <= 5e+59) {
tmp = fma((y * x), y, x);
} else {
tmp = (y * y) * x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(y * y) <= 5e+59) tmp = fma(Float64(y * x), y, x); else tmp = Float64(Float64(y * y) * x); end return tmp end
code[x_, y_] := If[LessEqual[N[(y * y), $MachinePrecision], 5e+59], N[(N[(y * x), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot y \leq 5 \cdot 10^{+59}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot y\right) \cdot x\\
\end{array}
\end{array}
if (*.f64 y y) < 4.9999999999999997e59Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6491.8
Applied rewrites91.8%
Applied rewrites91.8%
if 4.9999999999999997e59 < (*.f64 y y) Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6467.9
Applied rewrites67.9%
Taylor expanded in y around inf
Applied rewrites67.9%
(FPCore (x y) :precision binary64 (* (fma (* 0.16666666666666666 (* y y)) y 1.0) x))
double code(double x, double y) {
return fma((0.16666666666666666 * (y * y)), y, 1.0) * x;
}
function code(x, y) return Float64(fma(Float64(0.16666666666666666 * Float64(y * y)), y, 1.0) * x) end
code[x_, y_] := N[(N[(N[(0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(0.16666666666666666 \cdot \left(y \cdot y\right), y, 1\right) \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 rewrites76.4%
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.f6470.6
Applied rewrites70.6%
Taylor expanded in y around inf
Applied rewrites71.0%
Final simplification71.0%
(FPCore (x y) :precision binary64 (fma (* y y) x x))
double code(double x, double y) {
return fma((y * y), x, x);
}
function code(x, y) return fma(Float64(y * y), x, x) end
code[x_, y_] := N[(N[(y * y), $MachinePrecision] * x + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y \cdot y, x, x\right)
\end{array}
Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6481.5
Applied rewrites81.5%
(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 rewrites76.4%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6457.4
Applied rewrites57.4%
(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 rewrites76.4%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6457.4
Applied rewrites57.4%
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 2024255
(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))))