
(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 8 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 (* (sin (+ (* 0.5 eps) x)) (* -2.0 (expm1 (log1p (sin (* 0.5 eps)))))))
double code(double x, double eps) {
return sin(((0.5 * eps) + x)) * (-2.0 * expm1(log1p(sin((0.5 * eps)))));
}
public static double code(double x, double eps) {
return Math.sin(((0.5 * eps) + x)) * (-2.0 * Math.expm1(Math.log1p(Math.sin((0.5 * eps)))));
}
def code(x, eps): return math.sin(((0.5 * eps) + x)) * (-2.0 * math.expm1(math.log1p(math.sin((0.5 * eps)))))
function code(x, eps) return Float64(sin(Float64(Float64(0.5 * eps) + x)) * Float64(-2.0 * expm1(log1p(sin(Float64(0.5 * eps)))))) end
code[x_, eps_] := N[(N[Sin[N[(N[(0.5 * eps), $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision] * N[(-2.0 * N[(Exp[N[Log[1 + N[Sin[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(0.5 \cdot \varepsilon + x\right) \cdot \left(-2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(\sin \left(0.5 \cdot \varepsilon\right)\right)\right)\right)
\end{array}
Initial program 51.6%
diff-cos79.9%
div-inv79.9%
associate--l+79.9%
metadata-eval79.9%
div-inv79.9%
+-commutative79.9%
associate-+l+79.9%
metadata-eval79.9%
Applied egg-rr79.9%
associate-*r*79.9%
*-commutative79.9%
*-commutative79.9%
+-commutative79.9%
count-279.9%
fma-define79.9%
*-commutative79.9%
associate-+r-79.9%
+-commutative79.9%
associate--l+99.6%
+-inverses99.6%
distribute-lft-in99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in x around 0 99.6%
+-commutative99.6%
Simplified99.6%
expm1-log1p-u99.7%
expm1-undefine52.3%
+-rgt-identity52.3%
Applied egg-rr52.3%
expm1-define99.7%
Simplified99.7%
(FPCore (x eps) :precision binary64 (* (sin (+ (* 0.5 eps) x)) (* -2.0 (sin (* 0.5 eps)))))
double code(double x, double eps) {
return sin(((0.5 * eps) + x)) * (-2.0 * sin((0.5 * eps)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(((0.5d0 * eps) + x)) * ((-2.0d0) * sin((0.5d0 * eps)))
end function
public static double code(double x, double eps) {
return Math.sin(((0.5 * eps) + x)) * (-2.0 * Math.sin((0.5 * eps)));
}
def code(x, eps): return math.sin(((0.5 * eps) + x)) * (-2.0 * math.sin((0.5 * eps)))
function code(x, eps) return Float64(sin(Float64(Float64(0.5 * eps) + x)) * Float64(-2.0 * sin(Float64(0.5 * eps)))) end
function tmp = code(x, eps) tmp = sin(((0.5 * eps) + x)) * (-2.0 * sin((0.5 * eps))); end
code[x_, eps_] := N[(N[Sin[N[(N[(0.5 * eps), $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision] * N[(-2.0 * N[Sin[N[(0.5 * eps), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(0.5 \cdot \varepsilon + x\right) \cdot \left(-2 \cdot \sin \left(0.5 \cdot \varepsilon\right)\right)
\end{array}
Initial program 51.6%
diff-cos79.9%
div-inv79.9%
associate--l+79.9%
metadata-eval79.9%
div-inv79.9%
+-commutative79.9%
associate-+l+79.9%
metadata-eval79.9%
Applied egg-rr79.9%
associate-*r*79.9%
*-commutative79.9%
*-commutative79.9%
+-commutative79.9%
count-279.9%
fma-define79.9%
*-commutative79.9%
associate-+r-79.9%
+-commutative79.9%
associate--l+99.6%
+-inverses99.6%
distribute-lft-in99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in x around 0 99.6%
+-commutative99.6%
Simplified99.6%
+-rgt-identity99.6%
*-commutative99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (x eps) :precision binary64 (* eps (- (* (cos x) (* eps -0.5)) (sin x))))
double code(double x, double eps) {
return eps * ((cos(x) * (eps * -0.5)) - sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * ((cos(x) * (eps * (-0.5d0))) - sin(x))
end function
public static double code(double x, double eps) {
return eps * ((Math.cos(x) * (eps * -0.5)) - Math.sin(x));
}
def code(x, eps): return eps * ((math.cos(x) * (eps * -0.5)) - math.sin(x))
function code(x, eps) return Float64(eps * Float64(Float64(cos(x) * Float64(eps * -0.5)) - sin(x))) end
function tmp = code(x, eps) tmp = eps * ((cos(x) * (eps * -0.5)) - sin(x)); end
code[x_, eps_] := N[(eps * N[(N[(N[Cos[x], $MachinePrecision] * N[(eps * -0.5), $MachinePrecision]), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(\cos x \cdot \left(\varepsilon \cdot -0.5\right) - \sin x\right)
\end{array}
Initial program 51.6%
Taylor expanded in eps around 0 99.2%
associate-*r*99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (x eps) :precision binary64 (* (sin (+ (* 0.5 eps) x)) (- eps)))
double code(double x, double eps) {
return sin(((0.5 * eps) + x)) * -eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(((0.5d0 * eps) + x)) * -eps
end function
public static double code(double x, double eps) {
return Math.sin(((0.5 * eps) + x)) * -eps;
}
def code(x, eps): return math.sin(((0.5 * eps) + x)) * -eps
function code(x, eps) return Float64(sin(Float64(Float64(0.5 * eps) + x)) * Float64(-eps)) end
function tmp = code(x, eps) tmp = sin(((0.5 * eps) + x)) * -eps; end
code[x_, eps_] := N[(N[Sin[N[(N[(0.5 * eps), $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision] * (-eps)), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(0.5 \cdot \varepsilon + x\right) \cdot \left(-\varepsilon\right)
\end{array}
Initial program 51.6%
diff-cos79.9%
div-inv79.9%
associate--l+79.9%
metadata-eval79.9%
div-inv79.9%
+-commutative79.9%
associate-+l+79.9%
metadata-eval79.9%
Applied egg-rr79.9%
associate-*r*79.9%
*-commutative79.9%
*-commutative79.9%
+-commutative79.9%
count-279.9%
fma-define79.9%
*-commutative79.9%
associate-+r-79.9%
+-commutative79.9%
associate--l+99.6%
+-inverses99.6%
distribute-lft-in99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in x around 0 99.6%
+-commutative99.6%
Simplified99.6%
Taylor expanded in eps around 0 99.1%
mul-1-neg99.1%
Simplified99.1%
(FPCore (x eps) :precision binary64 (* eps (- (* eps -0.5) (sin x))))
double code(double x, double eps) {
return eps * ((eps * -0.5) - sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * ((eps * (-0.5d0)) - sin(x))
end function
public static double code(double x, double eps) {
return eps * ((eps * -0.5) - Math.sin(x));
}
def code(x, eps): return eps * ((eps * -0.5) - math.sin(x))
function code(x, eps) return Float64(eps * Float64(Float64(eps * -0.5) - sin(x))) end
function tmp = code(x, eps) tmp = eps * ((eps * -0.5) - sin(x)); end
code[x_, eps_] := N[(eps * N[(N[(eps * -0.5), $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(\varepsilon \cdot -0.5 - \sin x\right)
\end{array}
Initial program 51.6%
Taylor expanded in eps around 0 99.2%
associate-*r*99.2%
Simplified99.2%
Taylor expanded in x around 0 98.5%
*-commutative98.5%
Simplified98.5%
(FPCore (x eps) :precision binary64 (* eps (- (* eps -0.5) x)))
double code(double x, double eps) {
return eps * ((eps * -0.5) - x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * ((eps * (-0.5d0)) - x)
end function
public static double code(double x, double eps) {
return eps * ((eps * -0.5) - x);
}
def code(x, eps): return eps * ((eps * -0.5) - x)
function code(x, eps) return Float64(eps * Float64(Float64(eps * -0.5) - x)) end
function tmp = code(x, eps) tmp = eps * ((eps * -0.5) - x); end
code[x_, eps_] := N[(eps * N[(N[(eps * -0.5), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(\varepsilon \cdot -0.5 - x\right)
\end{array}
Initial program 51.6%
Taylor expanded in eps around 0 99.2%
associate-*r*99.2%
Simplified99.2%
Taylor expanded in x around 0 96.6%
Taylor expanded in eps around 0 96.7%
+-commutative96.7%
mul-1-neg96.7%
unsub-neg96.7%
*-commutative96.7%
Simplified96.7%
(FPCore (x eps) :precision binary64 (* eps (- x)))
double code(double x, double eps) {
return eps * -x;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps * -x
end function
public static double code(double x, double eps) {
return eps * -x;
}
def code(x, eps): return eps * -x
function code(x, eps) return Float64(eps * Float64(-x)) end
function tmp = code(x, eps) tmp = eps * -x; end
code[x_, eps_] := N[(eps * (-x)), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon \cdot \left(-x\right)
\end{array}
Initial program 51.6%
Taylor expanded in eps around 0 79.3%
associate-*r*79.3%
mul-1-neg79.3%
Simplified79.3%
Taylor expanded in x around 0 77.9%
associate-*r*77.9%
mul-1-neg77.9%
Simplified77.9%
Final simplification77.9%
(FPCore (x eps) :precision binary64 0.0)
double code(double x, double eps) {
return 0.0;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = 0.0d0
end function
public static double code(double x, double eps) {
return 0.0;
}
def code(x, eps): return 0.0
function code(x, eps) return 0.0 end
function tmp = code(x, eps) tmp = 0.0; end
code[x_, eps_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 51.6%
Taylor expanded in x around 0 49.8%
Taylor expanded in eps around 0 49.7%
metadata-eval49.7%
Applied egg-rr49.7%
(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 2024139
(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)))