
(FPCore (x eps) :precision binary64 (- (cos (+ x eps)) (cos x)))
double code(double x, double eps) {
return cos((x + eps)) - cos(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = cos((x + eps)) - cos(x)
end function
public static double code(double x, double eps) {
return Math.cos((x + eps)) - Math.cos(x);
}
def code(x, eps): return math.cos((x + eps)) - math.cos(x)
function code(x, eps) return Float64(cos(Float64(x + eps)) - cos(x)) end
function tmp = code(x, eps) tmp = cos((x + eps)) - cos(x); end
code[x_, eps_] := N[(N[Cos[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Cos[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos \left(x + \varepsilon\right) - \cos x
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x eps) :precision binary64 (- (cos (+ x eps)) (cos x)))
double code(double x, double eps) {
return cos((x + eps)) - cos(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = cos((x + eps)) - cos(x)
end function
public static double code(double x, double eps) {
return Math.cos((x + eps)) - Math.cos(x);
}
def code(x, eps): return math.cos((x + eps)) - math.cos(x)
function code(x, eps) return Float64(cos(Float64(x + eps)) - cos(x)) end
function tmp = code(x, eps) tmp = cos((x + eps)) - cos(x); end
code[x_, eps_] := N[(N[Cos[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Cos[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos \left(x + \varepsilon\right) - \cos x
\end{array}
(FPCore (x eps) :precision binary64 (let* ((t_0 (sin (* eps 0.5)))) (* (* -2.0 t_0) (+ (* (cos (* eps 0.5)) (sin x)) (* t_0 (cos x))))))
double code(double x, double eps) {
double t_0 = sin((eps * 0.5));
return (-2.0 * t_0) * ((cos((eps * 0.5)) * sin(x)) + (t_0 * cos(x)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
real(8) :: t_0
t_0 = sin((eps * 0.5d0))
code = ((-2.0d0) * t_0) * ((cos((eps * 0.5d0)) * sin(x)) + (t_0 * cos(x)))
end function
public static double code(double x, double eps) {
double t_0 = Math.sin((eps * 0.5));
return (-2.0 * t_0) * ((Math.cos((eps * 0.5)) * Math.sin(x)) + (t_0 * Math.cos(x)));
}
def code(x, eps): t_0 = math.sin((eps * 0.5)) return (-2.0 * t_0) * ((math.cos((eps * 0.5)) * math.sin(x)) + (t_0 * math.cos(x)))
function code(x, eps) t_0 = sin(Float64(eps * 0.5)) return Float64(Float64(-2.0 * t_0) * Float64(Float64(cos(Float64(eps * 0.5)) * sin(x)) + Float64(t_0 * cos(x)))) end
function tmp = code(x, eps) t_0 = sin((eps * 0.5)); tmp = (-2.0 * t_0) * ((cos((eps * 0.5)) * sin(x)) + (t_0 * cos(x))); end
code[x_, eps_] := Block[{t$95$0 = N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision]}, N[(N[(-2.0 * t$95$0), $MachinePrecision] * N[(N[(N[Cos[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(\varepsilon \cdot 0.5\right)\\
\left(-2 \cdot t\_0\right) \cdot \left(\cos \left(\varepsilon \cdot 0.5\right) \cdot \sin x + t\_0 \cdot \cos x\right)
\end{array}
\end{array}
Initial program 53.3%
diff-cos81.5%
div-inv81.5%
associate--l+81.5%
metadata-eval81.5%
div-inv81.5%
+-commutative81.5%
associate-+l+81.5%
metadata-eval81.5%
Applied egg-rr81.5%
associate-*r*81.5%
*-commutative81.5%
*-commutative81.5%
+-commutative81.5%
count-281.5%
fma-define81.5%
*-commutative81.5%
associate-+r-81.5%
+-commutative81.5%
associate--l+99.7%
+-inverses99.7%
distribute-lft-in99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 99.7%
*-commutative99.7%
Simplified99.7%
*-commutative99.7%
+-rgt-identity99.7%
*-commutative99.7%
sin-sum99.8%
distribute-lft-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
distribute-lft-out99.8%
*-commutative99.8%
*-commutative99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x eps)
:precision binary64
(*
eps
(-
(*
eps
(+
(* (cos x) -0.5)
(*
eps
(-
(* 0.041666666666666664 (* eps (cos x)))
(* (sin x) -0.16666666666666666)))))
(sin x))))
double code(double x, double eps) {
return eps * ((eps * ((cos(x) * -0.5) + (eps * ((0.041666666666666664 * (eps * cos(x))) - (sin(x) * -0.16666666666666666))))) - sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * ((eps * ((cos(x) * (-0.5d0)) + (eps * ((0.041666666666666664d0 * (eps * cos(x))) - (sin(x) * (-0.16666666666666666d0)))))) - sin(x))
end function
public static double code(double x, double eps) {
return eps * ((eps * ((Math.cos(x) * -0.5) + (eps * ((0.041666666666666664 * (eps * Math.cos(x))) - (Math.sin(x) * -0.16666666666666666))))) - Math.sin(x));
}
def code(x, eps): return eps * ((eps * ((math.cos(x) * -0.5) + (eps * ((0.041666666666666664 * (eps * math.cos(x))) - (math.sin(x) * -0.16666666666666666))))) - math.sin(x))
function code(x, eps) return Float64(eps * Float64(Float64(eps * Float64(Float64(cos(x) * -0.5) + Float64(eps * Float64(Float64(0.041666666666666664 * Float64(eps * cos(x))) - Float64(sin(x) * -0.16666666666666666))))) - sin(x))) end
function tmp = code(x, eps) tmp = eps * ((eps * ((cos(x) * -0.5) + (eps * ((0.041666666666666664 * (eps * cos(x))) - (sin(x) * -0.16666666666666666))))) - sin(x)); end
code[x_, eps_] := N[(eps * N[(N[(eps * N[(N[(N[Cos[x], $MachinePrecision] * -0.5), $MachinePrecision] + N[(eps * N[(N[(0.041666666666666664 * N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Sin[x], $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(\varepsilon \cdot \left(\cos x \cdot -0.5 + \varepsilon \cdot \left(0.041666666666666664 \cdot \left(\varepsilon \cdot \cos x\right) - \sin x \cdot -0.16666666666666666\right)\right) - \sin x\right)
\end{array}
Initial program 53.3%
Taylor expanded in eps around 0 99.8%
Final simplification99.8%
(FPCore (x eps) :precision binary64 (* (* -2.0 (sin (* eps 0.5))) (sin (+ (* eps 0.5) x))))
double code(double x, double eps) {
return (-2.0 * sin((eps * 0.5))) * sin(((eps * 0.5) + x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = ((-2.0d0) * sin((eps * 0.5d0))) * sin(((eps * 0.5d0) + x))
end function
public static double code(double x, double eps) {
return (-2.0 * Math.sin((eps * 0.5))) * Math.sin(((eps * 0.5) + x));
}
def code(x, eps): return (-2.0 * math.sin((eps * 0.5))) * math.sin(((eps * 0.5) + x))
function code(x, eps) return Float64(Float64(-2.0 * sin(Float64(eps * 0.5))) * sin(Float64(Float64(eps * 0.5) + x))) end
function tmp = code(x, eps) tmp = (-2.0 * sin((eps * 0.5))) * sin(((eps * 0.5) + x)); end
code[x_, eps_] := N[(N[(-2.0 * N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(eps * 0.5), $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-2 \cdot \sin \left(\varepsilon \cdot 0.5\right)\right) \cdot \sin \left(\varepsilon \cdot 0.5 + x\right)
\end{array}
Initial program 53.3%
diff-cos81.5%
div-inv81.5%
associate--l+81.5%
metadata-eval81.5%
div-inv81.5%
+-commutative81.5%
associate-+l+81.5%
metadata-eval81.5%
Applied egg-rr81.5%
associate-*r*81.5%
*-commutative81.5%
*-commutative81.5%
+-commutative81.5%
count-281.5%
fma-define81.5%
*-commutative81.5%
associate-+r-81.5%
+-commutative81.5%
associate--l+99.7%
+-inverses99.7%
distribute-lft-in99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in eps around inf 99.7%
metadata-eval99.7%
distribute-lft-neg-in99.7%
distribute-lft-neg-in99.7%
metadata-eval99.7%
*-commutative99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (x eps) :precision binary64 (* (sin (+ (* eps 0.5) x)) (- eps)))
double code(double x, double eps) {
return sin(((eps * 0.5) + x)) * -eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(((eps * 0.5d0) + x)) * -eps
end function
public static double code(double x, double eps) {
return Math.sin(((eps * 0.5) + x)) * -eps;
}
def code(x, eps): return math.sin(((eps * 0.5) + x)) * -eps
function code(x, eps) return Float64(sin(Float64(Float64(eps * 0.5) + x)) * Float64(-eps)) end
function tmp = code(x, eps) tmp = sin(((eps * 0.5) + x)) * -eps; end
code[x_, eps_] := N[(N[Sin[N[(N[(eps * 0.5), $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision] * (-eps)), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(\varepsilon \cdot 0.5 + x\right) \cdot \left(-\varepsilon\right)
\end{array}
Initial program 53.3%
diff-cos81.5%
div-inv81.5%
associate--l+81.5%
metadata-eval81.5%
div-inv81.5%
+-commutative81.5%
associate-+l+81.5%
metadata-eval81.5%
Applied egg-rr81.5%
associate-*r*81.5%
*-commutative81.5%
*-commutative81.5%
+-commutative81.5%
count-281.5%
fma-define81.5%
*-commutative81.5%
associate-+r-81.5%
+-commutative81.5%
associate--l+99.7%
+-inverses99.7%
distribute-lft-in99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in eps around 0 99.3%
mul-1-neg99.3%
Simplified99.3%
Final simplification99.3%
(FPCore (x eps) :precision binary64 (* -2.0 (* (* eps 0.5) (sin x))))
double code(double x, double eps) {
return -2.0 * ((eps * 0.5) * sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = (-2.0d0) * ((eps * 0.5d0) * sin(x))
end function
public static double code(double x, double eps) {
return -2.0 * ((eps * 0.5) * Math.sin(x));
}
def code(x, eps): return -2.0 * ((eps * 0.5) * math.sin(x))
function code(x, eps) return Float64(-2.0 * Float64(Float64(eps * 0.5) * sin(x))) end
function tmp = code(x, eps) tmp = -2.0 * ((eps * 0.5) * sin(x)); end
code[x_, eps_] := N[(-2.0 * N[(N[(eps * 0.5), $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-2 \cdot \left(\left(\varepsilon \cdot 0.5\right) \cdot \sin x\right)
\end{array}
Initial program 53.3%
diff-cos81.5%
*-commutative81.5%
div-inv81.5%
associate--l+81.5%
metadata-eval81.5%
div-inv81.5%
+-commutative81.5%
associate-+l+81.5%
metadata-eval81.5%
Applied egg-rr81.5%
Taylor expanded in eps around 0 79.5%
associate-*r*79.5%
*-commutative79.5%
Simplified79.5%
Final simplification79.5%
(FPCore (x eps) :precision binary64 (* eps (- (sin x))))
double code(double x, double eps) {
return eps * -sin(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * -sin(x)
end function
public static double code(double x, double eps) {
return eps * -Math.sin(x);
}
def code(x, eps): return eps * -math.sin(x)
function code(x, eps) return Float64(eps * Float64(-sin(x))) end
function tmp = code(x, eps) tmp = eps * -sin(x); end
code[x_, eps_] := N[(eps * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(-\sin x\right)
\end{array}
Initial program 53.3%
Taylor expanded in eps around 0 79.5%
associate-*r*79.5%
mul-1-neg79.5%
Simplified79.5%
Final simplification79.5%
(FPCore (x eps) :precision binary64 (+ (cos eps) -1.0))
double code(double x, double eps) {
return cos(eps) + -1.0;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = cos(eps) + (-1.0d0)
end function
public static double code(double x, double eps) {
return Math.cos(eps) + -1.0;
}
def code(x, eps): return math.cos(eps) + -1.0
function code(x, eps) return Float64(cos(eps) + -1.0) end
function tmp = code(x, eps) tmp = cos(eps) + -1.0; end
code[x_, eps_] := N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]
\begin{array}{l}
\\
\cos \varepsilon + -1
\end{array}
Initial program 53.3%
Taylor expanded in x around 0 52.0%
Final simplification52.0%
(FPCore (x eps) :precision binary64 (* (* -2.0 (sin (+ x (/ eps 2.0)))) (sin (/ eps 2.0))))
double code(double x, double eps) {
return (-2.0 * sin((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) * sin((x + (eps / 2.0d0)))) * sin((eps / 2.0d0))
end function
public static double code(double x, double eps) {
return (-2.0 * Math.sin((x + (eps / 2.0)))) * Math.sin((eps / 2.0));
}
def code(x, eps): return (-2.0 * math.sin((x + (eps / 2.0)))) * math.sin((eps / 2.0))
function code(x, eps) return Float64(Float64(-2.0 * sin(Float64(x + Float64(eps / 2.0)))) * sin(Float64(eps / 2.0))) end
function tmp = code(x, eps) tmp = (-2.0 * sin((x + (eps / 2.0)))) * sin((eps / 2.0)); end
code[x_, eps_] := N[(N[(-2.0 * N[Sin[N[(x + N[(eps / 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(eps / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-2 \cdot \sin \left(x + \frac{\varepsilon}{2}\right)\right) \cdot \sin \left(\frac{\varepsilon}{2}\right)
\end{array}
herbie shell --seed 2024113
(FPCore (x eps)
:name "2cos (problem 3.3.5)"
:precision binary64
:pre (and (and (and (<= -10000.0 x) (<= x 10000.0)) (< (* 1e-16 (fabs x)) eps)) (< eps (fabs x)))
:alt
(! :herbie-platform default (* -2 (sin (+ x (/ eps 2))) (sin (/ eps 2))))
(- (cos (+ x eps)) (cos x)))