
(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 260.0) (+ x (* x (* -0.16666666666666666 (* y y)))) (/ (/ (* x 6.0) y) y)))
double code(double x, double y) {
double tmp;
if (y <= 260.0) {
tmp = x + (x * (-0.16666666666666666 * (y * y)));
} else {
tmp = ((x * 6.0) / 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 <= 260.0d0) then
tmp = x + (x * ((-0.16666666666666666d0) * (y * y)))
else
tmp = ((x * 6.0d0) / y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 260.0) {
tmp = x + (x * (-0.16666666666666666 * (y * y)));
} else {
tmp = ((x * 6.0) / y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 260.0: tmp = x + (x * (-0.16666666666666666 * (y * y))) else: tmp = ((x * 6.0) / y) / y return tmp
function code(x, y) tmp = 0.0 if (y <= 260.0) tmp = Float64(x + Float64(x * Float64(-0.16666666666666666 * Float64(y * y)))); else tmp = Float64(Float64(Float64(x * 6.0) / y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 260.0) tmp = x + (x * (-0.16666666666666666 * (y * y))); else tmp = ((x * 6.0) / y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 260.0], N[(x + N[(x * N[(-0.16666666666666666 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * 6.0), $MachinePrecision] / y), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 260:\\
\;\;\;\;x + x \cdot \left(-0.16666666666666666 \cdot \left(y \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x \cdot 6}{y}}{y}\\
\end{array}
\end{array}
if y < 260Initial 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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.6%
Simplified68.6%
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6468.6%
Applied egg-rr68.6%
if 260 < 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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f642.2%
Simplified2.2%
*-commutativeN/A
flip-+N/A
*-rgt-identityN/A
*-inversesN/A
associate-/l*N/A
clear-numN/A
frac-timesN/A
metadata-evalN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr2.2%
Taylor expanded in y around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6432.1%
Simplified32.1%
Taylor expanded in y around inf
associate-*r/N/A
unpow2N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6432.9%
Simplified32.9%
Final simplification60.9%
(FPCore (x y) :precision binary64 (if (<= y 260.0) (* x (+ 1.0 (* y (* y -0.16666666666666666)))) (/ (/ (* x 6.0) y) y)))
double code(double x, double y) {
double tmp;
if (y <= 260.0) {
tmp = x * (1.0 + (y * (y * -0.16666666666666666)));
} else {
tmp = ((x * 6.0) / 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 <= 260.0d0) then
tmp = x * (1.0d0 + (y * (y * (-0.16666666666666666d0))))
else
tmp = ((x * 6.0d0) / y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 260.0) {
tmp = x * (1.0 + (y * (y * -0.16666666666666666)));
} else {
tmp = ((x * 6.0) / y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 260.0: tmp = x * (1.0 + (y * (y * -0.16666666666666666))) else: tmp = ((x * 6.0) / y) / y return tmp
function code(x, y) tmp = 0.0 if (y <= 260.0) tmp = Float64(x * Float64(1.0 + Float64(y * Float64(y * -0.16666666666666666)))); else tmp = Float64(Float64(Float64(x * 6.0) / y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 260.0) tmp = x * (1.0 + (y * (y * -0.16666666666666666))); else tmp = ((x * 6.0) / y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 260.0], N[(x * N[(1.0 + N[(y * N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * 6.0), $MachinePrecision] / y), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 260:\\
\;\;\;\;x \cdot \left(1 + y \cdot \left(y \cdot -0.16666666666666666\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x \cdot 6}{y}}{y}\\
\end{array}
\end{array}
if y < 260Initial 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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.6%
Simplified68.6%
if 260 < 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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f642.2%
Simplified2.2%
*-commutativeN/A
flip-+N/A
*-rgt-identityN/A
*-inversesN/A
associate-/l*N/A
clear-numN/A
frac-timesN/A
metadata-evalN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr2.2%
Taylor expanded in y around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6432.1%
Simplified32.1%
Taylor expanded in y around inf
associate-*r/N/A
unpow2N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6432.9%
Simplified32.9%
(FPCore (x y) :precision binary64 (if (<= y 2.4) x (/ (/ (* x 6.0) y) y)))
double code(double x, double y) {
double tmp;
if (y <= 2.4) {
tmp = x;
} else {
tmp = ((x * 6.0) / 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.4d0) then
tmp = x
else
tmp = ((x * 6.0d0) / y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 2.4) {
tmp = x;
} else {
tmp = ((x * 6.0) / y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 2.4: tmp = x else: tmp = ((x * 6.0) / y) / y return tmp
function code(x, y) tmp = 0.0 if (y <= 2.4) tmp = x; else tmp = Float64(Float64(Float64(x * 6.0) / y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 2.4) tmp = x; else tmp = ((x * 6.0) / y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 2.4], x, N[(N[(N[(x * 6.0), $MachinePrecision] / y), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.4:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x \cdot 6}{y}}{y}\\
\end{array}
\end{array}
if y < 2.39999999999999991Initial program 99.9%
Taylor expanded in y around 0
Simplified68.6%
if 2.39999999999999991 < 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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f642.2%
Simplified2.2%
*-commutativeN/A
flip-+N/A
*-rgt-identityN/A
*-inversesN/A
associate-/l*N/A
clear-numN/A
frac-timesN/A
metadata-evalN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr2.2%
Taylor expanded in y around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6432.1%
Simplified32.1%
Taylor expanded in y around inf
associate-*r/N/A
unpow2N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6432.9%
Simplified32.9%
(FPCore (x y) :precision binary64 (/ x (- 1.0 (* y (* y -0.16666666666666666)))))
double code(double x, double y) {
return x / (1.0 - (y * (y * -0.16666666666666666)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x / (1.0d0 - (y * (y * (-0.16666666666666666d0))))
end function
public static double code(double x, double y) {
return x / (1.0 - (y * (y * -0.16666666666666666)));
}
def code(x, y): return x / (1.0 - (y * (y * -0.16666666666666666)))
function code(x, y) return Float64(x / Float64(1.0 - Float64(y * Float64(y * -0.16666666666666666)))) end
function tmp = code(x, y) tmp = x / (1.0 - (y * (y * -0.16666666666666666))); end
code[x_, y_] := N[(x / N[(1.0 - N[(y * N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{1 - y \cdot \left(y \cdot -0.16666666666666666\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
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6454.3%
Simplified54.3%
*-commutativeN/A
flip-+N/A
*-rgt-identityN/A
*-inversesN/A
associate-/l*N/A
clear-numN/A
frac-timesN/A
metadata-evalN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr40.6%
Taylor expanded in y around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6451.9%
Simplified51.9%
Taylor expanded in x around 0
/-lowering-/.f64N/A
metadata-evalN/A
distribute-lft-neg-inN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6466.0%
Simplified66.0%
(FPCore (x y) :precision binary64 (if (<= y 5.8e+18) x 0.0))
double code(double x, double y) {
double tmp;
if (y <= 5.8e+18) {
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 <= 5.8d+18) 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 <= 5.8e+18) {
tmp = x;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 5.8e+18: tmp = x else: tmp = 0.0 return tmp
function code(x, y) tmp = 0.0 if (y <= 5.8e+18) tmp = x; else tmp = 0.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 5.8e+18) tmp = x; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 5.8e+18], x, 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 5.8 \cdot 10^{+18}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if y < 5.8e18Initial program 99.9%
Taylor expanded in y around 0
Simplified67.8%
if 5.8e18 < y Initial program 99.6%
Applied egg-rr33.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-rr14.6%
herbie shell --seed 2024145
(FPCore (x y)
:name "Linear.Quaternion:$cexp from linear-1.19.1.3"
:precision binary64
(* x (/ (sin y) y)))