
(FPCore (x y) :precision binary64 (* x (/ (sin y) y)))
double code(double x, double y) {
return x * (sin(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (sin(y) / y)
end function
public static double code(double x, double y) {
return x * (Math.sin(y) / y);
}
def code(x, y): return x * (math.sin(y) / y)
function code(x, y) return Float64(x * Float64(sin(y) / y)) end
function tmp = code(x, y) tmp = x * (sin(y) / y); end
code[x_, y_] := N[(x * N[(N[Sin[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \frac{\sin y}{y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (* x (/ (sin y) y)))
double code(double x, double y) {
return x * (sin(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (sin(y) / y)
end function
public static double code(double x, double y) {
return x * (Math.sin(y) / y);
}
def code(x, y): return x * (math.sin(y) / y)
function code(x, y) return Float64(x * Float64(sin(y) / y)) end
function tmp = code(x, y) tmp = x * (sin(y) / y); end
code[x_, y_] := N[(x * N[(N[Sin[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \frac{\sin y}{y}
\end{array}
(FPCore (x y) :precision binary64 (* x (/ (sin y) y)))
double code(double x, double y) {
return x * (sin(y) / y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (sin(y) / y)
end function
public static double code(double x, double y) {
return x * (Math.sin(y) / y);
}
def code(x, y): return x * (math.sin(y) / y)
function code(x, y) return Float64(x * Float64(sin(y) / y)) end
function tmp = code(x, y) tmp = x * (sin(y) / y); end
code[x_, y_] := N[(x * N[(N[Sin[y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \frac{\sin y}{y}
\end{array}
Initial program 99.8%
(FPCore (x y)
:precision binary64
(if (<= y 3200.0)
(fma
(* y y)
(*
x
(fma
(* y y)
(fma (* y y) -0.0001984126984126984 0.008333333333333333)
-0.16666666666666666))
x)
(/ (- 0.0 (/ x (fma y -0.16666666666666666 (/ -1.0 y)))) y)))
double code(double x, double y) {
double tmp;
if (y <= 3200.0) {
tmp = fma((y * y), (x * fma((y * y), fma((y * y), -0.0001984126984126984, 0.008333333333333333), -0.16666666666666666)), x);
} else {
tmp = (0.0 - (x / fma(y, -0.16666666666666666, (-1.0 / y)))) / y;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3200.0) tmp = fma(Float64(y * y), Float64(x * fma(Float64(y * y), fma(Float64(y * y), -0.0001984126984126984, 0.008333333333333333), -0.16666666666666666)), x); else tmp = Float64(Float64(0.0 - Float64(x / fma(y, -0.16666666666666666, Float64(-1.0 / y)))) / y); end return tmp end
code[x_, y_] := If[LessEqual[y, 3200.0], N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * -0.0001984126984126984 + 0.008333333333333333), $MachinePrecision] + -0.16666666666666666), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(N[(0.0 - N[(x / N[(y * -0.16666666666666666 + N[(-1.0 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3200:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, x \cdot \mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(y \cdot y, -0.0001984126984126984, 0.008333333333333333\right), -0.16666666666666666\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{0 - \frac{x}{\mathsf{fma}\left(y, -0.16666666666666666, \frac{-1}{y}\right)}}{y}\\
\end{array}
\end{array}
if y < 3200Initial program 99.9%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7
Applied egg-rr99.7%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified70.0%
if 3200 < y Initial program 99.7%
clear-numN/A
un-div-invN/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
frac-2negN/A
metadata-evalN/A
remove-double-negN/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
neg-sub0N/A
--lowering--.f6499.5
Applied egg-rr99.5%
Taylor expanded in y around 0
div-subN/A
unpow2N/A
associate-*r*N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
*-inversesN/A
associate-/r*N/A
unpow2N/A
*-rgt-identityN/A
associate-/l*N/A
sub-negN/A
*-commutativeN/A
distribute-rgt-neg-outN/A
accelerator-lowering-fma.f64N/A
distribute-rgt-neg-outN/A
associate-/l*N/A
*-rgt-identityN/A
unpow2N/A
associate-/r*N/A
*-inversesN/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f6424.5
Simplified24.5%
Final simplification59.4%
(FPCore (x y)
:precision binary64
(if (<= y 3200.0)
(fma
(* y y)
(*
x
(fma
(* y y)
(fma (* y y) -0.0001984126984126984 0.008333333333333333)
-0.16666666666666666))
x)
(/ 1.0 (/ (/ y x) y))))
double code(double x, double y) {
double tmp;
if (y <= 3200.0) {
tmp = fma((y * y), (x * fma((y * y), fma((y * y), -0.0001984126984126984, 0.008333333333333333), -0.16666666666666666)), x);
} else {
tmp = 1.0 / ((y / x) / y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3200.0) tmp = fma(Float64(y * y), Float64(x * fma(Float64(y * y), fma(Float64(y * y), -0.0001984126984126984, 0.008333333333333333), -0.16666666666666666)), x); else tmp = Float64(1.0 / Float64(Float64(y / x) / y)); end return tmp end
code[x_, y_] := If[LessEqual[y, 3200.0], N[(N[(y * y), $MachinePrecision] * N[(x * N[(N[(y * y), $MachinePrecision] * N[(N[(y * y), $MachinePrecision] * -0.0001984126984126984 + 0.008333333333333333), $MachinePrecision] + -0.16666666666666666), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(1.0 / N[(N[(y / x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3200:\\
\;\;\;\;\mathsf{fma}\left(y \cdot y, x \cdot \mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(y \cdot y, -0.0001984126984126984, 0.008333333333333333\right), -0.16666666666666666\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\frac{y}{x}}{y}}\\
\end{array}
\end{array}
if y < 3200Initial program 99.9%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7
Applied egg-rr99.7%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified70.0%
if 3200 < y Initial program 99.7%
associate-*r/N/A
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6499.4
Applied egg-rr99.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f644.2
Simplified4.2%
*-commutativeN/A
associate-*r*N/A
associate-/r/N/A
associate-*l/N/A
*-lft-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6423.6
Applied egg-rr23.6%
(FPCore (x y)
:precision binary64
(*
x
(/
-1.0
(fma
y
(fma y (fma y (fma y 0.008333333333333333 0.0) -0.16666666666666666) 0.0)
-1.0))))
double code(double x, double y) {
return x * (-1.0 / fma(y, fma(y, fma(y, fma(y, 0.008333333333333333, 0.0), -0.16666666666666666), 0.0), -1.0));
}
function code(x, y) return Float64(x * Float64(-1.0 / fma(y, fma(y, fma(y, fma(y, 0.008333333333333333, 0.0), -0.16666666666666666), 0.0), -1.0))) end
code[x_, y_] := N[(x * N[(-1.0 / N[(y * N[(y * N[(y * N[(y * 0.008333333333333333 + 0.0), $MachinePrecision] + -0.16666666666666666), $MachinePrecision] + 0.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \frac{-1}{\mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.008333333333333333, 0\right), -0.16666666666666666\right), 0\right), -1\right)}
\end{array}
Initial program 99.8%
Taylor expanded in y around 0
*-rgt-identityN/A
+-commutativeN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
distribute-lft-outN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
sub-negN/A
Simplified54.1%
Applied egg-rr53.5%
Taylor expanded in y around 0
Simplified64.0%
Final simplification64.0%
(FPCore (x y)
:precision binary64
(if (<= y 4.5)
(fma
y
(* y (* x (fma (* y y) 0.008333333333333333 -0.16666666666666666)))
x)
(/ 1.0 (/ (/ y x) y))))
double code(double x, double y) {
double tmp;
if (y <= 4.5) {
tmp = fma(y, (y * (x * fma((y * y), 0.008333333333333333, -0.16666666666666666))), x);
} else {
tmp = 1.0 / ((y / x) / y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 4.5) tmp = fma(y, Float64(y * Float64(x * fma(Float64(y * y), 0.008333333333333333, -0.16666666666666666))), x); else tmp = Float64(1.0 / Float64(Float64(y / x) / y)); end return tmp end
code[x_, y_] := If[LessEqual[y, 4.5], N[(y * N[(y * N[(x * N[(N[(y * y), $MachinePrecision] * 0.008333333333333333 + -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(1.0 / N[(N[(y / x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.5:\\
\;\;\;\;\mathsf{fma}\left(y, y \cdot \left(x \cdot \mathsf{fma}\left(y \cdot y, 0.008333333333333333, -0.16666666666666666\right)\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\frac{y}{x}}{y}}\\
\end{array}
\end{array}
if y < 4.5Initial program 99.9%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7
Applied egg-rr99.7%
associate-*r*N/A
div-invN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f6489.7
Applied egg-rr89.7%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified70.0%
if 4.5 < y Initial program 99.7%
associate-*r/N/A
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6499.4
Applied egg-rr99.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f644.2
Simplified4.2%
*-commutativeN/A
associate-*r*N/A
associate-/r/N/A
associate-*l/N/A
*-lft-identityN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6423.6
Applied egg-rr23.6%
(FPCore (x y)
:precision binary64
(if (<= y 4.5)
(fma
y
(* y (* x (fma (* y y) 0.008333333333333333 -0.16666666666666666)))
x)
(/ y (/ y x))))
double code(double x, double y) {
double tmp;
if (y <= 4.5) {
tmp = fma(y, (y * (x * fma((y * y), 0.008333333333333333, -0.16666666666666666))), x);
} else {
tmp = y / (y / x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 4.5) tmp = fma(y, Float64(y * Float64(x * fma(Float64(y * y), 0.008333333333333333, -0.16666666666666666))), x); else tmp = Float64(y / Float64(y / x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 4.5], N[(y * N[(y * N[(x * N[(N[(y * y), $MachinePrecision] * 0.008333333333333333 + -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(y / N[(y / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.5:\\
\;\;\;\;\mathsf{fma}\left(y, y \cdot \left(x \cdot \mathsf{fma}\left(y \cdot y, 0.008333333333333333, -0.16666666666666666\right)\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{\frac{y}{x}}\\
\end{array}
\end{array}
if y < 4.5Initial program 99.9%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7
Applied egg-rr99.7%
associate-*r*N/A
div-invN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f6489.7
Applied egg-rr89.7%
Taylor expanded in y around 0
+-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified70.0%
if 4.5 < y Initial program 99.7%
associate-*r/N/A
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6499.4
Applied egg-rr99.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f644.2
Simplified4.2%
*-commutativeN/A
associate-*r*N/A
associate-/r/N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f6423.6
Applied egg-rr23.6%
(FPCore (x y)
:precision binary64
(if (<= y 4.5)
(*
x
(fma (* y y) (fma y (* y 0.008333333333333333) -0.16666666666666666) 1.0))
(/ y (/ y x))))
double code(double x, double y) {
double tmp;
if (y <= 4.5) {
tmp = x * fma((y * y), fma(y, (y * 0.008333333333333333), -0.16666666666666666), 1.0);
} else {
tmp = y / (y / x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 4.5) tmp = Float64(x * fma(Float64(y * y), fma(y, Float64(y * 0.008333333333333333), -0.16666666666666666), 1.0)); else tmp = Float64(y / Float64(y / x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 4.5], N[(x * N[(N[(y * y), $MachinePrecision] * N[(y * N[(y * 0.008333333333333333), $MachinePrecision] + -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(y / N[(y / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.5:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y \cdot y, \mathsf{fma}\left(y, y \cdot 0.008333333333333333, -0.16666666666666666\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{\frac{y}{x}}\\
\end{array}
\end{array}
if y < 4.5Initial program 99.9%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7
Applied egg-rr99.7%
Taylor expanded in y around 0
distribute-lft-inN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
*-commutativeN/A
associate-*l*N/A
distribute-rgt1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
Simplified70.0%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6470.0
Simplified70.0%
if 4.5 < y Initial program 99.7%
associate-*r/N/A
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6499.4
Applied egg-rr99.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f644.2
Simplified4.2%
*-commutativeN/A
associate-*r*N/A
associate-/r/N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f6423.6
Applied egg-rr23.6%
Final simplification59.1%
(FPCore (x y) :precision binary64 (if (<= y 3200.0) (fma (* x (* y -0.16666666666666666)) y x) (/ y (/ y x))))
double code(double x, double y) {
double tmp;
if (y <= 3200.0) {
tmp = fma((x * (y * -0.16666666666666666)), y, x);
} else {
tmp = y / (y / x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3200.0) tmp = fma(Float64(x * Float64(y * -0.16666666666666666)), y, x); else tmp = Float64(y / Float64(y / x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 3200.0], N[(N[(x * N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(y / N[(y / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3200:\\
\;\;\;\;\mathsf{fma}\left(x \cdot \left(y \cdot -0.16666666666666666\right), y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{\frac{y}{x}}\\
\end{array}
\end{array}
if y < 3200Initial program 99.9%
Taylor expanded in y around 0
*-commutativeN/A
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6469.8
Simplified69.8%
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.8
Applied egg-rr69.8%
if 3200 < y Initial program 99.7%
associate-*r/N/A
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6499.4
Applied egg-rr99.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f644.2
Simplified4.2%
*-commutativeN/A
associate-*r*N/A
associate-/r/N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f6423.6
Applied egg-rr23.6%
(FPCore (x y) :precision binary64 (if (<= y 3200.0) (fma (* x (* y -0.16666666666666666)) y x) (* y (/ x y))))
double code(double x, double y) {
double tmp;
if (y <= 3200.0) {
tmp = fma((x * (y * -0.16666666666666666)), y, x);
} else {
tmp = y * (x / y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3200.0) tmp = fma(Float64(x * Float64(y * -0.16666666666666666)), y, x); else tmp = Float64(y * Float64(x / y)); end return tmp end
code[x_, y_] := If[LessEqual[y, 3200.0], N[(N[(x * N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(y * N[(x / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3200:\\
\;\;\;\;\mathsf{fma}\left(x \cdot \left(y \cdot -0.16666666666666666\right), y, x\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{x}{y}\\
\end{array}
\end{array}
if y < 3200Initial program 99.9%
Taylor expanded in y around 0
*-commutativeN/A
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6469.8
Simplified69.8%
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.8
Applied egg-rr69.8%
if 3200 < y Initial program 99.7%
associate-*r/N/A
associate-*l/N/A
*-lft-identityN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.6
Applied egg-rr99.6%
Taylor expanded in y around 0
Simplified23.2%
Final simplification58.9%
(FPCore (x y) :precision binary64 (if (<= y 3200.0) (* x (fma y (* y -0.16666666666666666) 1.0)) (* y (/ x y))))
double code(double x, double y) {
double tmp;
if (y <= 3200.0) {
tmp = x * fma(y, (y * -0.16666666666666666), 1.0);
} else {
tmp = y * (x / y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 3200.0) tmp = Float64(x * fma(y, Float64(y * -0.16666666666666666), 1.0)); else tmp = Float64(y * Float64(x / y)); end return tmp end
code[x_, y_] := If[LessEqual[y, 3200.0], N[(x * N[(y * N[(y * -0.16666666666666666), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(y * N[(x / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3200:\\
\;\;\;\;x \cdot \mathsf{fma}\left(y, y \cdot -0.16666666666666666, 1\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{x}{y}\\
\end{array}
\end{array}
if y < 3200Initial program 99.9%
Taylor expanded in y around 0
*-commutativeN/A
associate-*r*N/A
*-lft-identityN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6469.8
Simplified69.8%
if 3200 < y Initial program 99.7%
associate-*r/N/A
associate-*l/N/A
*-lft-identityN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
sin-lowering-sin.f6499.6
Applied egg-rr99.6%
Taylor expanded in y around 0
Simplified23.2%
Final simplification58.9%
(FPCore (x y) :precision binary64 x)
double code(double x, double y) {
return x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x
end function
public static double code(double x, double y) {
return x;
}
def code(x, y): return x
function code(x, y) return x end
function tmp = code(x, y) tmp = x; end
code[x_, y_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 99.8%
Taylor expanded in y around 0
Simplified54.7%
herbie shell --seed 2024196
(FPCore (x y)
:name "Linear.Quaternion:$cexp from linear-1.19.1.3"
:precision binary64
(* x (/ (sin y) y)))