
(FPCore (x eps) :precision binary64 (- (sin (+ x eps)) (sin x)))
double code(double x, double eps) {
return sin((x + eps)) - sin(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin((x + eps)) - sin(x)
end function
public static double code(double x, double eps) {
return Math.sin((x + eps)) - Math.sin(x);
}
def code(x, eps): return math.sin((x + eps)) - math.sin(x)
function code(x, eps) return Float64(sin(Float64(x + eps)) - sin(x)) end
function tmp = code(x, eps) tmp = sin((x + eps)) - sin(x); end
code[x_, eps_] := N[(N[Sin[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(x + \varepsilon\right) - \sin x
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 6 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x eps) :precision binary64 (- (sin (+ x eps)) (sin x)))
double code(double x, double eps) {
return sin((x + eps)) - sin(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin((x + eps)) - sin(x)
end function
public static double code(double x, double eps) {
return Math.sin((x + eps)) - Math.sin(x);
}
def code(x, eps): return math.sin((x + eps)) - math.sin(x)
function code(x, eps) return Float64(sin(Float64(x + eps)) - sin(x)) end
function tmp = code(x, eps) tmp = sin((x + eps)) - sin(x); end
code[x_, eps_] := N[(N[Sin[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(x + \varepsilon\right) - \sin x
\end{array}
(FPCore (x eps) :precision binary64 (- (* (sin eps) (cos x)) (* (sin eps) (* (tan (/ eps 2.0)) (sin x)))))
double code(double x, double eps) {
return (sin(eps) * cos(x)) - (sin(eps) * (tan((eps / 2.0)) * sin(x)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = (sin(eps) * cos(x)) - (sin(eps) * (tan((eps / 2.0d0)) * sin(x)))
end function
public static double code(double x, double eps) {
return (Math.sin(eps) * Math.cos(x)) - (Math.sin(eps) * (Math.tan((eps / 2.0)) * Math.sin(x)));
}
def code(x, eps): return (math.sin(eps) * math.cos(x)) - (math.sin(eps) * (math.tan((eps / 2.0)) * math.sin(x)))
function code(x, eps) return Float64(Float64(sin(eps) * cos(x)) - Float64(sin(eps) * Float64(tan(Float64(eps / 2.0)) * sin(x)))) end
function tmp = code(x, eps) tmp = (sin(eps) * cos(x)) - (sin(eps) * (tan((eps / 2.0)) * sin(x))); end
code[x_, eps_] := N[(N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[eps], $MachinePrecision] * N[(N[Tan[N[(eps / 2.0), $MachinePrecision]], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \varepsilon \cdot \cos x - \sin \varepsilon \cdot \left(\tan \left(\frac{\varepsilon}{2}\right) \cdot \sin x\right)
\end{array}
Initial program 46.3%
sin-sum67.9%
associate--l+67.9%
Applied egg-rr67.9%
+-commutative67.9%
associate-+l-99.3%
*-commutative99.3%
*-rgt-identity99.3%
distribute-lft-out--99.3%
Simplified99.3%
flip--99.2%
associate-*r/99.2%
metadata-eval99.2%
1-sub-cos99.5%
pow299.5%
Applied egg-rr99.5%
*-commutative99.5%
associate-/l*99.5%
Simplified99.5%
Taylor expanded in eps around inf 99.5%
associate-/l*99.5%
unpow299.5%
associate-*r/99.5%
associate-/r/99.5%
hang-0p-tan99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x eps) :precision binary64 (* (sin eps) (- (cos x) (* (sin x) (tan (* eps 0.5))))))
double code(double x, double eps) {
return sin(eps) * (cos(x) - (sin(x) * tan((eps * 0.5))));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(eps) * (cos(x) - (sin(x) * tan((eps * 0.5d0))))
end function
public static double code(double x, double eps) {
return Math.sin(eps) * (Math.cos(x) - (Math.sin(x) * Math.tan((eps * 0.5))));
}
def code(x, eps): return math.sin(eps) * (math.cos(x) - (math.sin(x) * math.tan((eps * 0.5))))
function code(x, eps) return Float64(sin(eps) * Float64(cos(x) - Float64(sin(x) * tan(Float64(eps * 0.5))))) end
function tmp = code(x, eps) tmp = sin(eps) * (cos(x) - (sin(x) * tan((eps * 0.5)))); end
code[x_, eps_] := N[(N[Sin[eps], $MachinePrecision] * N[(N[Cos[x], $MachinePrecision] - N[(N[Sin[x], $MachinePrecision] * N[Tan[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \varepsilon \cdot \left(\cos x - \sin x \cdot \tan \left(\varepsilon \cdot 0.5\right)\right)
\end{array}
Initial program 46.3%
sin-sum67.9%
associate--l+67.9%
Applied egg-rr67.9%
+-commutative67.9%
associate-+l-99.3%
*-commutative99.3%
*-rgt-identity99.3%
distribute-lft-out--99.3%
Simplified99.3%
flip--99.2%
associate-*r/99.2%
metadata-eval99.2%
1-sub-cos99.5%
pow299.5%
Applied egg-rr99.5%
*-commutative99.5%
associate-/l*99.5%
Simplified99.5%
Taylor expanded in eps around inf 99.5%
associate-/l*99.5%
unpow299.5%
associate-*r/99.5%
associate-/r/99.5%
hang-0p-tan99.6%
Simplified99.6%
distribute-lft-out--99.6%
*-commutative99.6%
div-inv99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (x eps) :precision binary64 (* 2.0 (* (sin (* eps 0.5)) (cos (* 0.5 (+ eps (* x 2.0)))))))
double code(double x, double eps) {
return 2.0 * (sin((eps * 0.5)) * cos((0.5 * (eps + (x * 2.0)))));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = 2.0d0 * (sin((eps * 0.5d0)) * cos((0.5d0 * (eps + (x * 2.0d0)))))
end function
public static double code(double x, double eps) {
return 2.0 * (Math.sin((eps * 0.5)) * Math.cos((0.5 * (eps + (x * 2.0)))));
}
def code(x, eps): return 2.0 * (math.sin((eps * 0.5)) * math.cos((0.5 * (eps + (x * 2.0)))))
function code(x, eps) return Float64(2.0 * Float64(sin(Float64(eps * 0.5)) * cos(Float64(0.5 * Float64(eps + Float64(x * 2.0)))))) end
function tmp = code(x, eps) tmp = 2.0 * (sin((eps * 0.5)) * cos((0.5 * (eps + (x * 2.0))))); end
code[x_, eps_] := N[(2.0 * N[(N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(0.5 * N[(eps + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\sin \left(\varepsilon \cdot 0.5\right) \cdot \cos \left(0.5 \cdot \left(\varepsilon + x \cdot 2\right)\right)\right)
\end{array}
Initial program 46.3%
add-sqr-sqrt22.6%
sqrt-unprod22.4%
pow222.4%
Applied egg-rr22.4%
sqrt-pow146.3%
diff-sin45.9%
metadata-eval45.9%
pow145.9%
div-inv45.9%
+-commutative45.9%
associate--l+78.7%
metadata-eval78.7%
div-inv78.7%
+-commutative78.7%
associate-+l+78.7%
metadata-eval78.7%
Applied egg-rr78.7%
*-commutative78.7%
+-inverses78.7%
*-commutative78.7%
count-278.7%
Simplified78.7%
Final simplification78.7%
(FPCore (x eps) :precision binary64 (if (or (<= eps -8e-6) (not (<= eps 1.9e-5))) (sin eps) (* eps (cos x))))
double code(double x, double eps) {
double tmp;
if ((eps <= -8e-6) || !(eps <= 1.9e-5)) {
tmp = sin(eps);
} else {
tmp = eps * cos(x);
}
return tmp;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
real(8) :: tmp
if ((eps <= (-8d-6)) .or. (.not. (eps <= 1.9d-5))) then
tmp = sin(eps)
else
tmp = eps * cos(x)
end if
code = tmp
end function
public static double code(double x, double eps) {
double tmp;
if ((eps <= -8e-6) || !(eps <= 1.9e-5)) {
tmp = Math.sin(eps);
} else {
tmp = eps * Math.cos(x);
}
return tmp;
}
def code(x, eps): tmp = 0 if (eps <= -8e-6) or not (eps <= 1.9e-5): tmp = math.sin(eps) else: tmp = eps * math.cos(x) return tmp
function code(x, eps) tmp = 0.0 if ((eps <= -8e-6) || !(eps <= 1.9e-5)) tmp = sin(eps); else tmp = Float64(eps * cos(x)); end return tmp end
function tmp_2 = code(x, eps) tmp = 0.0; if ((eps <= -8e-6) || ~((eps <= 1.9e-5))) tmp = sin(eps); else tmp = eps * cos(x); end tmp_2 = tmp; end
code[x_, eps_] := If[Or[LessEqual[eps, -8e-6], N[Not[LessEqual[eps, 1.9e-5]], $MachinePrecision]], N[Sin[eps], $MachinePrecision], N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -8 \cdot 10^{-6} \lor \neg \left(\varepsilon \leq 1.9 \cdot 10^{-5}\right):\\
\;\;\;\;\sin \varepsilon\\
\mathbf{else}:\\
\;\;\;\;\varepsilon \cdot \cos x\\
\end{array}
\end{array}
if eps < -7.99999999999999964e-6 or 1.9000000000000001e-5 < eps Initial program 60.7%
Taylor expanded in x around 0 61.7%
if -7.99999999999999964e-6 < eps < 1.9000000000000001e-5Initial program 29.8%
Taylor expanded in eps around 0 98.8%
Final simplification79.0%
(FPCore (x eps) :precision binary64 (sin eps))
double code(double x, double eps) {
return sin(eps);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(eps)
end function
public static double code(double x, double eps) {
return Math.sin(eps);
}
def code(x, eps): return math.sin(eps)
function code(x, eps) return sin(eps) end
function tmp = code(x, eps) tmp = sin(eps); end
code[x_, eps_] := N[Sin[eps], $MachinePrecision]
\begin{array}{l}
\\
\sin \varepsilon
\end{array}
Initial program 46.3%
Taylor expanded in x around 0 56.5%
Final simplification56.5%
(FPCore (x eps) :precision binary64 eps)
double code(double x, double eps) {
return eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps
end function
public static double code(double x, double eps) {
return eps;
}
def code(x, eps): return eps
function code(x, eps) return eps end
function tmp = code(x, eps) tmp = eps; end
code[x_, eps_] := eps
\begin{array}{l}
\\
\varepsilon
\end{array}
Initial program 46.3%
Taylor expanded in eps around 0 16.8%
Taylor expanded in x around 0 25.8%
Final simplification25.8%
(FPCore (x eps) :precision binary64 (fma (sin x) (- (cos eps) 1.0) (* (sin eps) (cos x))))
double code(double x, double eps) {
return fma(sin(x), (cos(eps) - 1.0), (sin(eps) * cos(x)));
}
function code(x, eps) return fma(sin(x), Float64(cos(eps) - 1.0), Float64(sin(eps) * cos(x))) end
code[x_, eps_] := N[(N[Sin[x], $MachinePrecision] * N[(N[Cos[eps], $MachinePrecision] - 1.0), $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\sin x, \cos \varepsilon - 1, \sin \varepsilon \cdot \cos x\right)
\end{array}
herbie shell --seed 2024021
(FPCore (x eps)
:name "2sin (example 3.3)"
:precision binary64
:herbie-target
(fma (sin x) (- (cos eps) 1.0) (* (sin eps) (cos x)))
(- (sin (+ x eps)) (sin x)))