
(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 11 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
(if (<= eps -0.00017)
(fma (sin x) (cos eps) (- (* (cos x) (sin eps)) (sin x)))
(if (<= eps 0.00018)
(+
(* -0.5 (* (sin x) (pow eps 2.0)))
(+ (* -0.16666666666666666 (* (cos x) (pow eps 3.0))) (* eps (cos x))))
(fma (cos eps) (sin x) (fma (sin eps) (cos x) (- (sin x)))))))
double code(double x, double eps) {
double tmp;
if (eps <= -0.00017) {
tmp = fma(sin(x), cos(eps), ((cos(x) * sin(eps)) - sin(x)));
} else if (eps <= 0.00018) {
tmp = (-0.5 * (sin(x) * pow(eps, 2.0))) + ((-0.16666666666666666 * (cos(x) * pow(eps, 3.0))) + (eps * cos(x)));
} else {
tmp = fma(cos(eps), sin(x), fma(sin(eps), cos(x), -sin(x)));
}
return tmp;
}
function code(x, eps) tmp = 0.0 if (eps <= -0.00017) tmp = fma(sin(x), cos(eps), Float64(Float64(cos(x) * sin(eps)) - sin(x))); elseif (eps <= 0.00018) tmp = Float64(Float64(-0.5 * Float64(sin(x) * (eps ^ 2.0))) + Float64(Float64(-0.16666666666666666 * Float64(cos(x) * (eps ^ 3.0))) + Float64(eps * cos(x)))); else tmp = fma(cos(eps), sin(x), fma(sin(eps), cos(x), Float64(-sin(x)))); end return tmp end
code[x_, eps_] := If[LessEqual[eps, -0.00017], N[(N[Sin[x], $MachinePrecision] * N[Cos[eps], $MachinePrecision] + N[(N[(N[Cos[x], $MachinePrecision] * N[Sin[eps], $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[eps, 0.00018], N[(N[(-0.5 * N[(N[Sin[x], $MachinePrecision] * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-0.16666666666666666 * N[(N[Cos[x], $MachinePrecision] * N[Power[eps, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Cos[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision] + (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -0.00017:\\
\;\;\;\;\mathsf{fma}\left(\sin x, \cos \varepsilon, \cos x \cdot \sin \varepsilon - \sin x\right)\\
\mathbf{elif}\;\varepsilon \leq 0.00018:\\
\;\;\;\;-0.5 \cdot \left(\sin x \cdot {\varepsilon}^{2}\right) + \left(-0.16666666666666666 \cdot \left(\cos x \cdot {\varepsilon}^{3}\right) + \varepsilon \cdot \cos x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\cos \varepsilon, \sin x, \mathsf{fma}\left(\sin \varepsilon, \cos x, -\sin x\right)\right)\\
\end{array}
\end{array}
if eps < -1.7e-4Initial program 52.2%
sin-sum99.4%
associate--l+99.5%
fma-def99.5%
Applied egg-rr99.5%
if -1.7e-4 < eps < 1.80000000000000011e-4Initial program 32.2%
Taylor expanded in eps around 0 99.8%
if 1.80000000000000011e-4 < eps Initial program 47.3%
sin-sum99.2%
associate--l+99.3%
Applied egg-rr99.3%
*-commutative99.3%
fma-udef99.5%
*-commutative99.5%
fma-neg99.5%
Simplified99.5%
Final simplification99.7%
(FPCore (x eps)
:precision binary64
(let* ((t_0 (sin (* 0.5 eps))))
(log1p
(expm1
(* (- (* (cos (* 0.5 eps)) (cos x)) (* t_0 (sin x))) (* t_0 2.0))))))
double code(double x, double eps) {
double t_0 = sin((0.5 * eps));
return log1p(expm1((((cos((0.5 * eps)) * cos(x)) - (t_0 * sin(x))) * (t_0 * 2.0))));
}
public static double code(double x, double eps) {
double t_0 = Math.sin((0.5 * eps));
return Math.log1p(Math.expm1((((Math.cos((0.5 * eps)) * Math.cos(x)) - (t_0 * Math.sin(x))) * (t_0 * 2.0))));
}
def code(x, eps): t_0 = math.sin((0.5 * eps)) return math.log1p(math.expm1((((math.cos((0.5 * eps)) * math.cos(x)) - (t_0 * math.sin(x))) * (t_0 * 2.0))))
function code(x, eps) t_0 = sin(Float64(0.5 * eps)) return log1p(expm1(Float64(Float64(Float64(cos(Float64(0.5 * eps)) * cos(x)) - Float64(t_0 * sin(x))) * Float64(t_0 * 2.0)))) end
code[x_, eps_] := Block[{t$95$0 = N[Sin[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision]}, N[Log[1 + N[(Exp[N[(N[(N[(N[Cos[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision] - N[(t$95$0 * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * 2.0), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(0.5 \cdot \varepsilon\right)\\
\mathsf{log1p}\left(\mathsf{expm1}\left(\left(\cos \left(0.5 \cdot \varepsilon\right) \cdot \cos x - t_0 \cdot \sin x\right) \cdot \left(t_0 \cdot 2\right)\right)\right)
\end{array}
\end{array}
Initial program 40.9%
diff-sin40.5%
div-inv40.5%
metadata-eval40.5%
div-inv40.5%
+-commutative40.5%
metadata-eval40.5%
Applied egg-rr40.5%
associate-*r*40.5%
*-commutative40.5%
associate-*l*40.5%
+-commutative40.5%
associate--l+75.7%
+-inverses75.7%
*-commutative75.7%
associate-+r+75.7%
+-commutative75.7%
Simplified75.7%
Taylor expanded in eps around inf 75.7%
*-commutative75.7%
+-commutative75.7%
*-lft-identity75.7%
metadata-eval75.7%
cancel-sign-sub-inv75.7%
*-commutative75.7%
associate-*r*75.7%
Simplified75.7%
log1p-expm1-u75.7%
*-commutative75.7%
associate-*l*75.7%
sub-neg75.7%
distribute-rgt-neg-in75.7%
metadata-eval75.7%
+-rgt-identity75.7%
+-rgt-identity75.7%
metadata-eval75.7%
div-inv75.7%
+-rgt-identity75.7%
+-rgt-identity75.7%
div-inv75.7%
metadata-eval75.7%
*-commutative75.7%
Applied egg-rr75.7%
distribute-lft-in75.7%
cos-sum99.5%
*-commutative99.5%
associate-*r*99.5%
metadata-eval99.5%
*-un-lft-identity99.5%
*-commutative99.5%
associate-*r*99.5%
metadata-eval99.5%
*-un-lft-identity99.5%
Applied egg-rr99.5%
Final simplification99.5%
(FPCore (x eps)
:precision binary64
(let* ((t_0 (- (sin (+ eps x)) (sin x))))
(if (or (<= t_0 -0.002) (not (<= t_0 1e-13)))
t_0
(* (sin (* 0.5 eps)) (* (cos x) 2.0)))))
double code(double x, double eps) {
double t_0 = sin((eps + x)) - sin(x);
double tmp;
if ((t_0 <= -0.002) || !(t_0 <= 1e-13)) {
tmp = t_0;
} else {
tmp = sin((0.5 * eps)) * (cos(x) * 2.0);
}
return tmp;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
real(8) :: t_0
real(8) :: tmp
t_0 = sin((eps + x)) - sin(x)
if ((t_0 <= (-0.002d0)) .or. (.not. (t_0 <= 1d-13))) then
tmp = t_0
else
tmp = sin((0.5d0 * eps)) * (cos(x) * 2.0d0)
end if
code = tmp
end function
public static double code(double x, double eps) {
double t_0 = Math.sin((eps + x)) - Math.sin(x);
double tmp;
if ((t_0 <= -0.002) || !(t_0 <= 1e-13)) {
tmp = t_0;
} else {
tmp = Math.sin((0.5 * eps)) * (Math.cos(x) * 2.0);
}
return tmp;
}
def code(x, eps): t_0 = math.sin((eps + x)) - math.sin(x) tmp = 0 if (t_0 <= -0.002) or not (t_0 <= 1e-13): tmp = t_0 else: tmp = math.sin((0.5 * eps)) * (math.cos(x) * 2.0) return tmp
function code(x, eps) t_0 = Float64(sin(Float64(eps + x)) - sin(x)) tmp = 0.0 if ((t_0 <= -0.002) || !(t_0 <= 1e-13)) tmp = t_0; else tmp = Float64(sin(Float64(0.5 * eps)) * Float64(cos(x) * 2.0)); end return tmp end
function tmp_2 = code(x, eps) t_0 = sin((eps + x)) - sin(x); tmp = 0.0; if ((t_0 <= -0.002) || ~((t_0 <= 1e-13))) tmp = t_0; else tmp = sin((0.5 * eps)) * (cos(x) * 2.0); end tmp_2 = tmp; end
code[x_, eps_] := Block[{t$95$0 = N[(N[Sin[N[(eps + x), $MachinePrecision]], $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -0.002], N[Not[LessEqual[t$95$0, 1e-13]], $MachinePrecision]], t$95$0, N[(N[Sin[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision] * N[(N[Cos[x], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(\varepsilon + x\right) - \sin x\\
\mathbf{if}\;t_0 \leq -0.002 \lor \neg \left(t_0 \leq 10^{-13}\right):\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\sin \left(0.5 \cdot \varepsilon\right) \cdot \left(\cos x \cdot 2\right)\\
\end{array}
\end{array}
if (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) < -2e-3 or 1e-13 < (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) Initial program 65.0%
if -2e-3 < (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) < 1e-13Initial program 25.2%
diff-sin25.2%
div-inv25.2%
metadata-eval25.2%
div-inv25.2%
+-commutative25.2%
metadata-eval25.2%
Applied egg-rr25.2%
associate-*r*25.2%
*-commutative25.2%
associate-*l*25.2%
+-commutative25.2%
associate--l+83.6%
+-inverses83.6%
*-commutative83.6%
associate-+r+83.6%
+-commutative83.6%
Simplified83.6%
Taylor expanded in eps around inf 83.6%
*-commutative83.6%
+-commutative83.6%
*-lft-identity83.6%
metadata-eval83.6%
cancel-sign-sub-inv83.6%
*-commutative83.6%
associate-*r*83.6%
Simplified83.6%
Taylor expanded in eps around 0 83.5%
Final simplification76.2%
(FPCore (x eps)
:precision binary64
(if (or (<= eps -0.000155) (not (<= eps 0.0002)))
(fma (sin x) (cos eps) (- (* (cos x) (sin eps)) (sin x)))
(+
(* -0.5 (* (sin x) (pow eps 2.0)))
(+ (* -0.16666666666666666 (* (cos x) (pow eps 3.0))) (* eps (cos x))))))
double code(double x, double eps) {
double tmp;
if ((eps <= -0.000155) || !(eps <= 0.0002)) {
tmp = fma(sin(x), cos(eps), ((cos(x) * sin(eps)) - sin(x)));
} else {
tmp = (-0.5 * (sin(x) * pow(eps, 2.0))) + ((-0.16666666666666666 * (cos(x) * pow(eps, 3.0))) + (eps * cos(x)));
}
return tmp;
}
function code(x, eps) tmp = 0.0 if ((eps <= -0.000155) || !(eps <= 0.0002)) tmp = fma(sin(x), cos(eps), Float64(Float64(cos(x) * sin(eps)) - sin(x))); else tmp = Float64(Float64(-0.5 * Float64(sin(x) * (eps ^ 2.0))) + Float64(Float64(-0.16666666666666666 * Float64(cos(x) * (eps ^ 3.0))) + Float64(eps * cos(x)))); end return tmp end
code[x_, eps_] := If[Or[LessEqual[eps, -0.000155], N[Not[LessEqual[eps, 0.0002]], $MachinePrecision]], N[(N[Sin[x], $MachinePrecision] * N[Cos[eps], $MachinePrecision] + N[(N[(N[Cos[x], $MachinePrecision] * N[Sin[eps], $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(-0.5 * N[(N[Sin[x], $MachinePrecision] * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-0.16666666666666666 * N[(N[Cos[x], $MachinePrecision] * N[Power[eps, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -0.000155 \lor \neg \left(\varepsilon \leq 0.0002\right):\\
\;\;\;\;\mathsf{fma}\left(\sin x, \cos \varepsilon, \cos x \cdot \sin \varepsilon - \sin x\right)\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \left(\sin x \cdot {\varepsilon}^{2}\right) + \left(-0.16666666666666666 \cdot \left(\cos x \cdot {\varepsilon}^{3}\right) + \varepsilon \cdot \cos x\right)\\
\end{array}
\end{array}
if eps < -1.55e-4 or 2.0000000000000001e-4 < eps Initial program 50.0%
sin-sum99.3%
associate--l+99.4%
fma-def99.5%
Applied egg-rr99.5%
if -1.55e-4 < eps < 2.0000000000000001e-4Initial program 32.2%
Taylor expanded in eps around 0 99.8%
Final simplification99.7%
(FPCore (x eps)
:precision binary64
(if (or (<= eps -0.00019) (not (<= eps 0.00018)))
(+ (- (* (cos x) (sin eps)) (sin x)) (* (sin x) (cos eps)))
(+
(* -0.5 (* (sin x) (pow eps 2.0)))
(+ (* -0.16666666666666666 (* (cos x) (pow eps 3.0))) (* eps (cos x))))))
double code(double x, double eps) {
double tmp;
if ((eps <= -0.00019) || !(eps <= 0.00018)) {
tmp = ((cos(x) * sin(eps)) - sin(x)) + (sin(x) * cos(eps));
} else {
tmp = (-0.5 * (sin(x) * pow(eps, 2.0))) + ((-0.16666666666666666 * (cos(x) * pow(eps, 3.0))) + (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 <= (-0.00019d0)) .or. (.not. (eps <= 0.00018d0))) then
tmp = ((cos(x) * sin(eps)) - sin(x)) + (sin(x) * cos(eps))
else
tmp = ((-0.5d0) * (sin(x) * (eps ** 2.0d0))) + (((-0.16666666666666666d0) * (cos(x) * (eps ** 3.0d0))) + (eps * cos(x)))
end if
code = tmp
end function
public static double code(double x, double eps) {
double tmp;
if ((eps <= -0.00019) || !(eps <= 0.00018)) {
tmp = ((Math.cos(x) * Math.sin(eps)) - Math.sin(x)) + (Math.sin(x) * Math.cos(eps));
} else {
tmp = (-0.5 * (Math.sin(x) * Math.pow(eps, 2.0))) + ((-0.16666666666666666 * (Math.cos(x) * Math.pow(eps, 3.0))) + (eps * Math.cos(x)));
}
return tmp;
}
def code(x, eps): tmp = 0 if (eps <= -0.00019) or not (eps <= 0.00018): tmp = ((math.cos(x) * math.sin(eps)) - math.sin(x)) + (math.sin(x) * math.cos(eps)) else: tmp = (-0.5 * (math.sin(x) * math.pow(eps, 2.0))) + ((-0.16666666666666666 * (math.cos(x) * math.pow(eps, 3.0))) + (eps * math.cos(x))) return tmp
function code(x, eps) tmp = 0.0 if ((eps <= -0.00019) || !(eps <= 0.00018)) tmp = Float64(Float64(Float64(cos(x) * sin(eps)) - sin(x)) + Float64(sin(x) * cos(eps))); else tmp = Float64(Float64(-0.5 * Float64(sin(x) * (eps ^ 2.0))) + Float64(Float64(-0.16666666666666666 * Float64(cos(x) * (eps ^ 3.0))) + Float64(eps * cos(x)))); end return tmp end
function tmp_2 = code(x, eps) tmp = 0.0; if ((eps <= -0.00019) || ~((eps <= 0.00018))) tmp = ((cos(x) * sin(eps)) - sin(x)) + (sin(x) * cos(eps)); else tmp = (-0.5 * (sin(x) * (eps ^ 2.0))) + ((-0.16666666666666666 * (cos(x) * (eps ^ 3.0))) + (eps * cos(x))); end tmp_2 = tmp; end
code[x_, eps_] := If[Or[LessEqual[eps, -0.00019], N[Not[LessEqual[eps, 0.00018]], $MachinePrecision]], N[(N[(N[(N[Cos[x], $MachinePrecision] * N[Sin[eps], $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[x], $MachinePrecision] * N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(-0.5 * N[(N[Sin[x], $MachinePrecision] * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-0.16666666666666666 * N[(N[Cos[x], $MachinePrecision] * N[Power[eps, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -0.00019 \lor \neg \left(\varepsilon \leq 0.00018\right):\\
\;\;\;\;\left(\cos x \cdot \sin \varepsilon - \sin x\right) + \sin x \cdot \cos \varepsilon\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \left(\sin x \cdot {\varepsilon}^{2}\right) + \left(-0.16666666666666666 \cdot \left(\cos x \cdot {\varepsilon}^{3}\right) + \varepsilon \cdot \cos x\right)\\
\end{array}
\end{array}
if eps < -1.9000000000000001e-4 or 1.80000000000000011e-4 < eps Initial program 50.0%
sin-sum99.3%
associate--l+99.4%
Applied egg-rr99.4%
if -1.9000000000000001e-4 < eps < 1.80000000000000011e-4Initial program 32.2%
Taylor expanded in eps around 0 99.8%
Final simplification99.6%
(FPCore (x eps)
:precision binary64
(if (or (<= eps -0.00019) (not (<= eps 0.0002)))
(+ (- (* (cos x) (sin eps)) (sin x)) (* (sin x) (cos eps)))
(fma
-0.5
(* (sin x) (* eps eps))
(* (cos x) (+ eps (* -0.16666666666666666 (pow eps 3.0)))))))
double code(double x, double eps) {
double tmp;
if ((eps <= -0.00019) || !(eps <= 0.0002)) {
tmp = ((cos(x) * sin(eps)) - sin(x)) + (sin(x) * cos(eps));
} else {
tmp = fma(-0.5, (sin(x) * (eps * eps)), (cos(x) * (eps + (-0.16666666666666666 * pow(eps, 3.0)))));
}
return tmp;
}
function code(x, eps) tmp = 0.0 if ((eps <= -0.00019) || !(eps <= 0.0002)) tmp = Float64(Float64(Float64(cos(x) * sin(eps)) - sin(x)) + Float64(sin(x) * cos(eps))); else tmp = fma(-0.5, Float64(sin(x) * Float64(eps * eps)), Float64(cos(x) * Float64(eps + Float64(-0.16666666666666666 * (eps ^ 3.0))))); end return tmp end
code[x_, eps_] := If[Or[LessEqual[eps, -0.00019], N[Not[LessEqual[eps, 0.0002]], $MachinePrecision]], N[(N[(N[(N[Cos[x], $MachinePrecision] * N[Sin[eps], $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[x], $MachinePrecision] * N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(N[Sin[x], $MachinePrecision] * N[(eps * eps), $MachinePrecision]), $MachinePrecision] + N[(N[Cos[x], $MachinePrecision] * N[(eps + N[(-0.16666666666666666 * N[Power[eps, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -0.00019 \lor \neg \left(\varepsilon \leq 0.0002\right):\\
\;\;\;\;\left(\cos x \cdot \sin \varepsilon - \sin x\right) + \sin x \cdot \cos \varepsilon\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \sin x \cdot \left(\varepsilon \cdot \varepsilon\right), \cos x \cdot \left(\varepsilon + -0.16666666666666666 \cdot {\varepsilon}^{3}\right)\right)\\
\end{array}
\end{array}
if eps < -1.9000000000000001e-4 or 2.0000000000000001e-4 < eps Initial program 50.0%
sin-sum99.3%
associate--l+99.4%
Applied egg-rr99.4%
if -1.9000000000000001e-4 < eps < 2.0000000000000001e-4Initial program 32.2%
Taylor expanded in eps around 0 99.8%
fma-def99.8%
*-commutative99.8%
unpow299.8%
+-commutative99.8%
associate-*r*99.8%
distribute-rgt-out99.8%
Simplified99.8%
Final simplification99.6%
(FPCore (x eps) :precision binary64 (* (sin (* 0.5 eps)) (* 2.0 (cos (* 0.5 (- eps (* x -2.0)))))))
double code(double x, double eps) {
return sin((0.5 * eps)) * (2.0 * cos((0.5 * (eps - (x * -2.0)))));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin((0.5d0 * eps)) * (2.0d0 * cos((0.5d0 * (eps - (x * (-2.0d0))))))
end function
public static double code(double x, double eps) {
return Math.sin((0.5 * eps)) * (2.0 * Math.cos((0.5 * (eps - (x * -2.0)))));
}
def code(x, eps): return math.sin((0.5 * eps)) * (2.0 * math.cos((0.5 * (eps - (x * -2.0)))))
function code(x, eps) return Float64(sin(Float64(0.5 * eps)) * Float64(2.0 * cos(Float64(0.5 * Float64(eps - Float64(x * -2.0)))))) end
function tmp = code(x, eps) tmp = sin((0.5 * eps)) * (2.0 * cos((0.5 * (eps - (x * -2.0))))); end
code[x_, eps_] := N[(N[Sin[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[Cos[N[(0.5 * N[(eps - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(0.5 \cdot \varepsilon\right) \cdot \left(2 \cdot \cos \left(0.5 \cdot \left(\varepsilon - x \cdot -2\right)\right)\right)
\end{array}
Initial program 40.9%
diff-sin40.5%
div-inv40.5%
metadata-eval40.5%
div-inv40.5%
+-commutative40.5%
metadata-eval40.5%
Applied egg-rr40.5%
associate-*r*40.5%
*-commutative40.5%
associate-*l*40.5%
+-commutative40.5%
associate--l+75.7%
+-inverses75.7%
*-commutative75.7%
associate-+r+75.7%
+-commutative75.7%
Simplified75.7%
Taylor expanded in eps around inf 75.7%
*-commutative75.7%
+-commutative75.7%
*-lft-identity75.7%
metadata-eval75.7%
cancel-sign-sub-inv75.7%
*-commutative75.7%
associate-*r*75.7%
Simplified75.7%
Final simplification75.7%
(FPCore (x eps) :precision binary64 (if (or (<= eps -0.0007) (not (<= eps 0.0011))) (- (sin eps) (sin x)) (* eps (cos x))))
double code(double x, double eps) {
double tmp;
if ((eps <= -0.0007) || !(eps <= 0.0011)) {
tmp = sin(eps) - sin(x);
} 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 <= (-0.0007d0)) .or. (.not. (eps <= 0.0011d0))) then
tmp = sin(eps) - sin(x)
else
tmp = eps * cos(x)
end if
code = tmp
end function
public static double code(double x, double eps) {
double tmp;
if ((eps <= -0.0007) || !(eps <= 0.0011)) {
tmp = Math.sin(eps) - Math.sin(x);
} else {
tmp = eps * Math.cos(x);
}
return tmp;
}
def code(x, eps): tmp = 0 if (eps <= -0.0007) or not (eps <= 0.0011): tmp = math.sin(eps) - math.sin(x) else: tmp = eps * math.cos(x) return tmp
function code(x, eps) tmp = 0.0 if ((eps <= -0.0007) || !(eps <= 0.0011)) tmp = Float64(sin(eps) - sin(x)); else tmp = Float64(eps * cos(x)); end return tmp end
function tmp_2 = code(x, eps) tmp = 0.0; if ((eps <= -0.0007) || ~((eps <= 0.0011))) tmp = sin(eps) - sin(x); else tmp = eps * cos(x); end tmp_2 = tmp; end
code[x_, eps_] := If[Or[LessEqual[eps, -0.0007], N[Not[LessEqual[eps, 0.0011]], $MachinePrecision]], N[(N[Sin[eps], $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision], N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -0.0007 \lor \neg \left(\varepsilon \leq 0.0011\right):\\
\;\;\;\;\sin \varepsilon - \sin x\\
\mathbf{else}:\\
\;\;\;\;\varepsilon \cdot \cos x\\
\end{array}
\end{array}
if eps < -6.99999999999999993e-4 or 0.00110000000000000007 < eps Initial program 50.4%
sin-sum99.4%
Applied egg-rr99.4%
sin-sum50.4%
+-commutative50.4%
*-un-lft-identity50.4%
metadata-eval50.4%
associate-*r*50.4%
count-250.4%
flip-+0.0%
+-inverses0.0%
metadata-eval0.0%
metadata-eval0.0%
metadata-eval0.0%
+-inverses0.0%
metadata-eval0.0%
flip--52.4%
metadata-eval52.4%
metadata-eval52.4%
+-rgt-identity52.4%
add-sqr-sqrt22.4%
sqrt-unprod26.1%
pow226.1%
Applied egg-rr26.1%
Taylor expanded in eps around inf 52.4%
if -6.99999999999999993e-4 < eps < 0.00110000000000000007Initial program 32.0%
Taylor expanded in eps around 0 98.5%
Final simplification76.2%
(FPCore (x eps) :precision binary64 (if (<= eps -9.8e-6) (sin eps) (if (<= eps 0.00105) (* eps (cos x)) (sin eps))))
double code(double x, double eps) {
double tmp;
if (eps <= -9.8e-6) {
tmp = sin(eps);
} else if (eps <= 0.00105) {
tmp = eps * cos(x);
} else {
tmp = sin(eps);
}
return tmp;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
real(8) :: tmp
if (eps <= (-9.8d-6)) then
tmp = sin(eps)
else if (eps <= 0.00105d0) then
tmp = eps * cos(x)
else
tmp = sin(eps)
end if
code = tmp
end function
public static double code(double x, double eps) {
double tmp;
if (eps <= -9.8e-6) {
tmp = Math.sin(eps);
} else if (eps <= 0.00105) {
tmp = eps * Math.cos(x);
} else {
tmp = Math.sin(eps);
}
return tmp;
}
def code(x, eps): tmp = 0 if eps <= -9.8e-6: tmp = math.sin(eps) elif eps <= 0.00105: tmp = eps * math.cos(x) else: tmp = math.sin(eps) return tmp
function code(x, eps) tmp = 0.0 if (eps <= -9.8e-6) tmp = sin(eps); elseif (eps <= 0.00105) tmp = Float64(eps * cos(x)); else tmp = sin(eps); end return tmp end
function tmp_2 = code(x, eps) tmp = 0.0; if (eps <= -9.8e-6) tmp = sin(eps); elseif (eps <= 0.00105) tmp = eps * cos(x); else tmp = sin(eps); end tmp_2 = tmp; end
code[x_, eps_] := If[LessEqual[eps, -9.8e-6], N[Sin[eps], $MachinePrecision], If[LessEqual[eps, 0.00105], N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision], N[Sin[eps], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -9.8 \cdot 10^{-6}:\\
\;\;\;\;\sin \varepsilon\\
\mathbf{elif}\;\varepsilon \leq 0.00105:\\
\;\;\;\;\varepsilon \cdot \cos x\\
\mathbf{else}:\\
\;\;\;\;\sin \varepsilon\\
\end{array}
\end{array}
if eps < -9.79999999999999934e-6 or 0.00104999999999999994 < eps Initial program 50.4%
Taylor expanded in x around 0 51.6%
if -9.79999999999999934e-6 < eps < 0.00104999999999999994Initial program 32.0%
Taylor expanded in eps around 0 98.5%
Final simplification75.8%
(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 40.9%
Taylor expanded in x around 0 53.1%
Final simplification53.1%
(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 40.9%
diff-sin40.5%
div-inv40.5%
metadata-eval40.5%
div-inv40.5%
+-commutative40.5%
metadata-eval40.5%
Applied egg-rr40.5%
associate-*r*40.5%
*-commutative40.5%
associate-*l*40.5%
+-commutative40.5%
associate--l+75.7%
+-inverses75.7%
*-commutative75.7%
associate-+r+75.7%
+-commutative75.7%
Simplified75.7%
Taylor expanded in eps around 0 52.3%
*-commutative52.3%
Simplified52.3%
Taylor expanded in x around 0 29.5%
Final simplification29.5%
(FPCore (x eps) :precision binary64 (* 2.0 (* (cos (+ x (/ eps 2.0))) (sin (/ eps 2.0)))))
double code(double x, double eps) {
return 2.0 * (cos((x + (eps / 2.0))) * sin((eps / 2.0)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = 2.0d0 * (cos((x + (eps / 2.0d0))) * sin((eps / 2.0d0)))
end function
public static double code(double x, double eps) {
return 2.0 * (Math.cos((x + (eps / 2.0))) * Math.sin((eps / 2.0)));
}
def code(x, eps): return 2.0 * (math.cos((x + (eps / 2.0))) * math.sin((eps / 2.0)))
function code(x, eps) return Float64(2.0 * Float64(cos(Float64(x + Float64(eps / 2.0))) * sin(Float64(eps / 2.0)))) end
function tmp = code(x, eps) tmp = 2.0 * (cos((x + (eps / 2.0))) * sin((eps / 2.0))); end
code[x_, eps_] := N[(2.0 * N[(N[Cos[N[(x + N[(eps / 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(eps / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\cos \left(x + \frac{\varepsilon}{2}\right) \cdot \sin \left(\frac{\varepsilon}{2}\right)\right)
\end{array}
herbie shell --seed 2023279
(FPCore (x eps)
:name "2sin (example 3.3)"
:precision binary64
:herbie-target
(* 2.0 (* (cos (+ x (/ eps 2.0))) (sin (/ eps 2.0))))
(- (sin (+ x eps)) (sin x)))