
(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 7 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 320000.0) (+ x (* y (* x (* y -0.16666666666666666)))) (/ x (* 0.16666666666666666 (* y y)))))
double code(double x, double y) {
double tmp;
if (y <= 320000.0) {
tmp = x + (y * (x * (y * -0.16666666666666666)));
} else {
tmp = x / (0.16666666666666666 * (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 <= 320000.0d0) then
tmp = x + (y * (x * (y * (-0.16666666666666666d0))))
else
tmp = x / (0.16666666666666666d0 * (y * y))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 320000.0) {
tmp = x + (y * (x * (y * -0.16666666666666666)));
} else {
tmp = x / (0.16666666666666666 * (y * y));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 320000.0: tmp = x + (y * (x * (y * -0.16666666666666666))) else: tmp = x / (0.16666666666666666 * (y * y)) return tmp
function code(x, y) tmp = 0.0 if (y <= 320000.0) tmp = Float64(x + Float64(y * Float64(x * Float64(y * -0.16666666666666666)))); else tmp = Float64(x / Float64(0.16666666666666666 * Float64(y * y))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 320000.0) tmp = x + (y * (x * (y * -0.16666666666666666))); else tmp = x / (0.16666666666666666 * (y * y)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 320000.0], N[(x + N[(y * N[(x * N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 320000:\\
\;\;\;\;x + y \cdot \left(x \cdot \left(y \cdot -0.16666666666666666\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{0.16666666666666666 \cdot \left(y \cdot y\right)}\\
\end{array}
\end{array}
if y < 3.2e5Initial program 99.9%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6467.2%
Simplified67.2%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6467.2%
Applied egg-rr67.2%
distribute-lft-inN/A
*-rgt-identityN/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.2%
Applied egg-rr67.2%
if 3.2e5 < y Initial program 99.6%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f642.3%
Simplified2.3%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
swap-sqrN/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f641.3%
Applied egg-rr1.3%
Taylor expanded in y around 0
Simplified38.1%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.1%
Simplified38.1%
Final simplification60.1%
(FPCore (x y) :precision binary64 (if (<= y 320000.0) (* x (+ 1.0 (* (* y y) -0.16666666666666666))) (/ x (* 0.16666666666666666 (* y y)))))
double code(double x, double y) {
double tmp;
if (y <= 320000.0) {
tmp = x * (1.0 + ((y * y) * -0.16666666666666666));
} else {
tmp = x / (0.16666666666666666 * (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 <= 320000.0d0) then
tmp = x * (1.0d0 + ((y * y) * (-0.16666666666666666d0)))
else
tmp = x / (0.16666666666666666d0 * (y * y))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 320000.0) {
tmp = x * (1.0 + ((y * y) * -0.16666666666666666));
} else {
tmp = x / (0.16666666666666666 * (y * y));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 320000.0: tmp = x * (1.0 + ((y * y) * -0.16666666666666666)) else: tmp = x / (0.16666666666666666 * (y * y)) return tmp
function code(x, y) tmp = 0.0 if (y <= 320000.0) tmp = Float64(x * Float64(1.0 + Float64(Float64(y * y) * -0.16666666666666666))); else tmp = Float64(x / Float64(0.16666666666666666 * Float64(y * y))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 320000.0) tmp = x * (1.0 + ((y * y) * -0.16666666666666666)); else tmp = x / (0.16666666666666666 * (y * y)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 320000.0], N[(x * N[(1.0 + N[(N[(y * y), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 320000:\\
\;\;\;\;x \cdot \left(1 + \left(y \cdot y\right) \cdot -0.16666666666666666\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{0.16666666666666666 \cdot \left(y \cdot y\right)}\\
\end{array}
\end{array}
if y < 3.2e5Initial program 99.9%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6467.2%
Simplified67.2%
if 3.2e5 < y Initial program 99.6%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f642.3%
Simplified2.3%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
swap-sqrN/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f641.3%
Applied egg-rr1.3%
Taylor expanded in y around 0
Simplified38.1%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.1%
Simplified38.1%
Final simplification60.1%
(FPCore (x y) :precision binary64 (if (<= y 2.5) x (/ x (* 0.16666666666666666 (* y y)))))
double code(double x, double y) {
double tmp;
if (y <= 2.5) {
tmp = x;
} else {
tmp = x / (0.16666666666666666 * (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 <= 2.5d0) then
tmp = x
else
tmp = x / (0.16666666666666666d0 * (y * y))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 2.5) {
tmp = x;
} else {
tmp = x / (0.16666666666666666 * (y * y));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 2.5: tmp = x else: tmp = x / (0.16666666666666666 * (y * y)) return tmp
function code(x, y) tmp = 0.0 if (y <= 2.5) tmp = x; else tmp = Float64(x / Float64(0.16666666666666666 * Float64(y * y))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 2.5) tmp = x; else tmp = x / (0.16666666666666666 * (y * y)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 2.5], x, N[(x / N[(0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.5:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{0.16666666666666666 \cdot \left(y \cdot y\right)}\\
\end{array}
\end{array}
if y < 2.5Initial program 99.9%
Taylor expanded in y around 0
Simplified67.7%
if 2.5 < y Initial program 99.6%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f642.4%
Simplified2.4%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
swap-sqrN/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f641.4%
Applied egg-rr1.4%
Taylor expanded in y around 0
Simplified37.6%
Taylor expanded in y around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.6%
Simplified37.6%
(FPCore (x y) :precision binary64 (/ x (+ 1.0 (* 0.16666666666666666 (* y y)))))
double code(double x, double y) {
return x / (1.0 + (0.16666666666666666 * (y * y)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x / (1.0d0 + (0.16666666666666666d0 * (y * y)))
end function
public static double code(double x, double y) {
return x / (1.0 + (0.16666666666666666 * (y * y)));
}
def code(x, y): return x / (1.0 + (0.16666666666666666 * (y * y)))
function code(x, y) return Float64(x / Float64(1.0 + Float64(0.16666666666666666 * Float64(y * y)))) end
function tmp = code(x, y) tmp = x / (1.0 + (0.16666666666666666 * (y * y))); end
code[x_, y_] := N[(x / N[(1.0 + N[(0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{1 + 0.16666666666666666 \cdot \left(y \cdot y\right)}
\end{array}
Initial program 99.8%
Taylor expanded in y around 0
*-rgt-identityN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6451.3%
Simplified51.3%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
swap-sqrN/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
*-lowering-*.f6450.8%
Applied egg-rr50.8%
Taylor expanded in y around 0
Simplified66.6%
(FPCore (x y) :precision binary64 (if (<= y 1.46e+44) x 0.0))
double code(double x, double y) {
double tmp;
if (y <= 1.46e+44) {
tmp = x;
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.46d+44) then
tmp = x
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 1.46e+44) {
tmp = x;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 1.46e+44: tmp = x else: tmp = 0.0 return tmp
function code(x, y) tmp = 0.0 if (y <= 1.46e+44) tmp = x; else tmp = 0.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 1.46e+44) tmp = x; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 1.46e+44], x, 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.46 \cdot 10^{+44}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if y < 1.4599999999999999e44Initial program 99.8%
Taylor expanded in y around 0
Simplified65.2%
if 1.4599999999999999e44 < y Initial program 99.7%
Applied egg-rr41.8%
(FPCore (x y) :precision binary64 0.0)
double code(double x, double y) {
return 0.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 0.0d0
end function
public static double code(double x, double y) {
return 0.0;
}
def code(x, y): return 0.0
function code(x, y) return 0.0 end
function tmp = code(x, y) tmp = 0.0; end
code[x_, y_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 99.8%
Applied egg-rr18.2%
herbie shell --seed 2024158
(FPCore (x y)
:name "Linear.Quaternion:$cexp from linear-1.19.1.3"
:precision binary64
(* x (/ (sin y) y)))