
(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 (- (/ (* (cos x) (pow (sin eps) 2.0)) (- -1.0 (cos eps))) (* (sin eps) (sin x))))
double code(double x, double eps) {
return ((cos(x) * pow(sin(eps), 2.0)) / (-1.0 - cos(eps))) - (sin(eps) * sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = ((cos(x) * (sin(eps) ** 2.0d0)) / ((-1.0d0) - cos(eps))) - (sin(eps) * sin(x))
end function
public static double code(double x, double eps) {
return ((Math.cos(x) * Math.pow(Math.sin(eps), 2.0)) / (-1.0 - Math.cos(eps))) - (Math.sin(eps) * Math.sin(x));
}
def code(x, eps): return ((math.cos(x) * math.pow(math.sin(eps), 2.0)) / (-1.0 - math.cos(eps))) - (math.sin(eps) * math.sin(x))
function code(x, eps) return Float64(Float64(Float64(cos(x) * (sin(eps) ^ 2.0)) / Float64(-1.0 - cos(eps))) - Float64(sin(eps) * sin(x))) end
function tmp = code(x, eps) tmp = ((cos(x) * (sin(eps) ^ 2.0)) / (-1.0 - cos(eps))) - (sin(eps) * sin(x)); end
code[x_, eps_] := N[(N[(N[(N[Cos[x], $MachinePrecision] * N[Power[N[Sin[eps], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\cos x \cdot {\sin \varepsilon}^{2}}{-1 - \cos \varepsilon} - \sin \varepsilon \cdot \sin x
\end{array}
Initial program 54.3%
sub-neg54.3%
cos-sum54.5%
associate-+l-54.4%
add-sqr-sqrt53.7%
associate-*l*53.7%
fma-neg53.7%
Applied egg-rr53.7%
Taylor expanded in x around inf 54.4%
associate--r+80.6%
sub-neg80.6%
*-rgt-identity80.6%
cancel-sign-sub-inv80.6%
*-commutative80.6%
distribute-lft-out--80.6%
sub-neg80.6%
metadata-eval80.6%
+-commutative80.6%
*-commutative80.6%
Simplified80.6%
flip-+80.7%
metadata-eval80.7%
1-sub-cos99.7%
pow299.7%
Applied egg-rr99.7%
associate-*r/99.8%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x eps) :precision binary64 (- (* (cos x) (/ (pow (sin eps) 2.0) (- -1.0 (cos eps)))) (* (sin eps) (sin x))))
double code(double x, double eps) {
return (cos(x) * (pow(sin(eps), 2.0) / (-1.0 - cos(eps)))) - (sin(eps) * sin(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = (cos(x) * ((sin(eps) ** 2.0d0) / ((-1.0d0) - cos(eps)))) - (sin(eps) * sin(x))
end function
public static double code(double x, double eps) {
return (Math.cos(x) * (Math.pow(Math.sin(eps), 2.0) / (-1.0 - Math.cos(eps)))) - (Math.sin(eps) * Math.sin(x));
}
def code(x, eps): return (math.cos(x) * (math.pow(math.sin(eps), 2.0) / (-1.0 - math.cos(eps)))) - (math.sin(eps) * math.sin(x))
function code(x, eps) return Float64(Float64(cos(x) * Float64((sin(eps) ^ 2.0) / Float64(-1.0 - cos(eps)))) - Float64(sin(eps) * sin(x))) end
function tmp = code(x, eps) tmp = (cos(x) * ((sin(eps) ^ 2.0) / (-1.0 - cos(eps)))) - (sin(eps) * sin(x)); end
code[x_, eps_] := N[(N[(N[Cos[x], $MachinePrecision] * N[(N[Power[N[Sin[eps], $MachinePrecision], 2.0], $MachinePrecision] / N[(-1.0 - N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos x \cdot \frac{{\sin \varepsilon}^{2}}{-1 - \cos \varepsilon} - \sin \varepsilon \cdot \sin x
\end{array}
Initial program 54.3%
sub-neg54.3%
cos-sum54.5%
associate-+l-54.4%
add-sqr-sqrt53.7%
associate-*l*53.7%
fma-neg53.7%
Applied egg-rr53.7%
Taylor expanded in x around inf 54.4%
associate--r+80.6%
sub-neg80.6%
*-rgt-identity80.6%
cancel-sign-sub-inv80.6%
*-commutative80.6%
distribute-lft-out--80.6%
sub-neg80.6%
metadata-eval80.6%
+-commutative80.6%
*-commutative80.6%
Simplified80.6%
flip-+80.7%
metadata-eval80.7%
1-sub-cos99.7%
pow299.7%
Applied egg-rr99.7%
Final simplification99.7%
(FPCore (x eps) :precision binary64 (* (sin (* eps 0.5)) (* -2.0 (log1p (expm1 (sin (* 0.5 (- eps (* x -2.0)))))))))
double code(double x, double eps) {
return sin((eps * 0.5)) * (-2.0 * log1p(expm1(sin((0.5 * (eps - (x * -2.0)))))));
}
public static double code(double x, double eps) {
return Math.sin((eps * 0.5)) * (-2.0 * Math.log1p(Math.expm1(Math.sin((0.5 * (eps - (x * -2.0)))))));
}
def code(x, eps): return math.sin((eps * 0.5)) * (-2.0 * math.log1p(math.expm1(math.sin((0.5 * (eps - (x * -2.0)))))))
function code(x, eps) return Float64(sin(Float64(eps * 0.5)) * Float64(-2.0 * log1p(expm1(sin(Float64(0.5 * Float64(eps - Float64(x * -2.0)))))))) end
code[x_, eps_] := N[(N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision] * N[(-2.0 * N[Log[1 + N[(Exp[N[Sin[N[(0.5 * N[(eps - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(\varepsilon \cdot 0.5\right) \cdot \left(-2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\sin \left(0.5 \cdot \left(\varepsilon - x \cdot -2\right)\right)\right)\right)\right)
\end{array}
Initial program 54.3%
diff-cos81.2%
div-inv81.2%
associate--l+81.2%
metadata-eval81.2%
div-inv81.2%
+-commutative81.2%
associate-+l+81.2%
metadata-eval81.2%
Applied egg-rr81.2%
associate-*r*81.2%
*-commutative81.2%
associate-*l*81.2%
sub-neg81.2%
mul-1-neg81.2%
+-commutative81.2%
associate-+r+99.6%
mul-1-neg99.6%
sub-neg99.6%
+-inverses99.6%
remove-double-neg99.6%
mul-1-neg99.6%
sub-neg99.6%
neg-sub099.6%
mul-1-neg99.6%
remove-double-neg99.6%
*-commutative99.6%
+-commutative99.6%
Simplified99.6%
log1p-expm1-u99.7%
Applied egg-rr99.7%
Taylor expanded in x around -inf 99.7%
Final simplification99.7%
(FPCore (x eps) :precision binary64 (* (sin (* eps 0.5)) (* -2.0 (sin (* 0.5 (- eps (* x -2.0)))))))
double code(double x, double eps) {
return sin((eps * 0.5)) * (-2.0 * sin((0.5 * (eps - (x * -2.0)))));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin((eps * 0.5d0)) * ((-2.0d0) * sin((0.5d0 * (eps - (x * (-2.0d0))))))
end function
public static double code(double x, double eps) {
return Math.sin((eps * 0.5)) * (-2.0 * Math.sin((0.5 * (eps - (x * -2.0)))));
}
def code(x, eps): return math.sin((eps * 0.5)) * (-2.0 * math.sin((0.5 * (eps - (x * -2.0)))))
function code(x, eps) return Float64(sin(Float64(eps * 0.5)) * Float64(-2.0 * sin(Float64(0.5 * Float64(eps - Float64(x * -2.0)))))) end
function tmp = code(x, eps) tmp = sin((eps * 0.5)) * (-2.0 * sin((0.5 * (eps - (x * -2.0))))); end
code[x_, eps_] := N[(N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision] * N[(-2.0 * N[Sin[N[(0.5 * N[(eps - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \left(\varepsilon \cdot 0.5\right) \cdot \left(-2 \cdot \sin \left(0.5 \cdot \left(\varepsilon - x \cdot -2\right)\right)\right)
\end{array}
Initial program 54.3%
diff-cos81.2%
div-inv81.2%
associate--l+81.2%
metadata-eval81.2%
div-inv81.2%
+-commutative81.2%
associate-+l+81.2%
metadata-eval81.2%
Applied egg-rr81.2%
associate-*r*81.2%
*-commutative81.2%
associate-*l*81.2%
sub-neg81.2%
mul-1-neg81.2%
+-commutative81.2%
associate-+r+99.6%
mul-1-neg99.6%
sub-neg99.6%
+-inverses99.6%
remove-double-neg99.6%
mul-1-neg99.6%
sub-neg99.6%
neg-sub099.6%
mul-1-neg99.6%
remove-double-neg99.6%
*-commutative99.6%
+-commutative99.6%
Simplified99.6%
Taylor expanded in x around -inf 99.6%
Final simplification99.6%
(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 54.3%
Taylor expanded in eps around 0 98.6%
+-commutative98.6%
mul-1-neg98.6%
unsub-neg98.6%
associate-*r*98.6%
*-commutative98.6%
Simplified98.6%
add-cube-cbrt98.6%
pow398.6%
Applied egg-rr98.6%
Taylor expanded in x around 0 97.5%
unpow1/397.7%
*-lft-identity97.7%
Simplified97.7%
Taylor expanded in x around inf 97.7%
*-commutative97.7%
fma-neg97.7%
pow-base-197.7%
*-lft-identity97.7%
rem-square-sqrt0.0%
fma-define0.0%
unpow20.0%
swap-sqr0.0%
associate-*l*0.0%
distribute-rgt-neg-in0.0%
distribute-lft-out0.0%
*-commutative0.0%
associate-*r*0.0%
rem-square-sqrt97.8%
Simplified97.8%
Final simplification97.8%
(FPCore (x eps) :precision binary64 (* (sin x) (- eps)))
double code(double x, double eps) {
return sin(x) * -eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = sin(x) * -eps
end function
public static double code(double x, double eps) {
return Math.sin(x) * -eps;
}
def code(x, eps): return math.sin(x) * -eps
function code(x, eps) return Float64(sin(x) * Float64(-eps)) end
function tmp = code(x, eps) tmp = sin(x) * -eps; end
code[x_, eps_] := N[(N[Sin[x], $MachinePrecision] * (-eps)), $MachinePrecision]
\begin{array}{l}
\\
\sin x \cdot \left(-\varepsilon\right)
\end{array}
Initial program 54.3%
Taylor expanded in eps around 0 79.2%
mul-1-neg79.2%
*-commutative79.2%
distribute-rgt-neg-in79.2%
Simplified79.2%
Final simplification79.2%
(FPCore (x eps) :precision binary64 (* x (- eps)))
double code(double x, double eps) {
return x * -eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = x * -eps
end function
public static double code(double x, double eps) {
return x * -eps;
}
def code(x, eps): return x * -eps
function code(x, eps) return Float64(x * Float64(-eps)) end
function tmp = code(x, eps) tmp = x * -eps; end
code[x_, eps_] := N[(x * (-eps)), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(-\varepsilon\right)
\end{array}
Initial program 54.3%
Taylor expanded in eps around 0 79.2%
mul-1-neg79.2%
*-commutative79.2%
distribute-rgt-neg-in79.2%
Simplified79.2%
Taylor expanded in x around 0 77.6%
associate-*r*77.6%
neg-mul-177.6%
Simplified77.6%
Final simplification77.6%
(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 2024040
(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)))
:herbie-target
(* (* -2.0 (sin (+ x (/ eps 2.0)))) (sin (/ eps 2.0)))
(- (cos (+ x eps)) (cos x)))