
(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 10 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 (fma (sin x) (* (sin eps) (- (tan (/ eps 2.0)))) (* (sin eps) (cos x))))
double code(double x, double eps) {
return fma(sin(x), (sin(eps) * -tan((eps / 2.0))), (sin(eps) * cos(x)));
}
function code(x, eps) return fma(sin(x), Float64(sin(eps) * Float64(-tan(Float64(eps / 2.0)))), Float64(sin(eps) * cos(x))) end
code[x_, eps_] := N[(N[Sin[x], $MachinePrecision] * N[(N[Sin[eps], $MachinePrecision] * (-N[Tan[N[(eps / 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\sin x, \sin \varepsilon \cdot \left(-\tan \left(\frac{\varepsilon}{2}\right)\right), \sin \varepsilon \cdot \cos x\right)
\end{array}
Initial program 40.4%
sin-sum63.7%
associate--l+63.6%
Applied egg-rr63.6%
+-commutative63.6%
associate-+l-99.4%
*-commutative99.4%
*-rgt-identity99.4%
distribute-lft-out--99.3%
Simplified99.3%
Taylor expanded in eps around inf 99.3%
sub-neg99.3%
distribute-rgt-neg-out99.3%
*-commutative99.3%
+-commutative99.3%
fma-def99.4%
sub-neg99.4%
+-commutative99.4%
distribute-neg-in99.4%
remove-double-neg99.4%
metadata-eval99.4%
*-commutative99.4%
Simplified99.4%
+-commutative99.4%
flip-+99.3%
metadata-eval99.3%
1-sub-cos99.5%
unpow299.5%
Applied egg-rr99.5%
Taylor expanded in eps around inf 99.5%
metadata-eval99.5%
times-frac99.5%
distribute-lft-in99.5%
metadata-eval99.5%
neg-mul-199.5%
sub-neg99.5%
associate-*l/99.5%
*-commutative99.5%
unpow299.5%
associate-*r*99.5%
associate-*r/99.5%
sub-neg99.5%
metadata-eval99.5%
neg-mul-199.5%
distribute-lft-in99.5%
*-commutative99.5%
times-frac99.5%
hang-0p-tan99.6%
metadata-eval99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x eps)
:precision binary64
(let* ((t_0 (- (sin (+ x eps)) (sin x))))
(if (or (<= t_0 -0.02) (not (<= t_0 5e-141)))
t_0
(* (cos x) (* 2.0 (sin (* eps 0.5)))))))
double code(double x, double eps) {
double t_0 = sin((x + eps)) - sin(x);
double tmp;
if ((t_0 <= -0.02) || !(t_0 <= 5e-141)) {
tmp = t_0;
} else {
tmp = cos(x) * (2.0 * sin((eps * 0.5)));
}
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((x + eps)) - sin(x)
if ((t_0 <= (-0.02d0)) .or. (.not. (t_0 <= 5d-141))) then
tmp = t_0
else
tmp = cos(x) * (2.0d0 * sin((eps * 0.5d0)))
end if
code = tmp
end function
public static double code(double x, double eps) {
double t_0 = Math.sin((x + eps)) - Math.sin(x);
double tmp;
if ((t_0 <= -0.02) || !(t_0 <= 5e-141)) {
tmp = t_0;
} else {
tmp = Math.cos(x) * (2.0 * Math.sin((eps * 0.5)));
}
return tmp;
}
def code(x, eps): t_0 = math.sin((x + eps)) - math.sin(x) tmp = 0 if (t_0 <= -0.02) or not (t_0 <= 5e-141): tmp = t_0 else: tmp = math.cos(x) * (2.0 * math.sin((eps * 0.5))) return tmp
function code(x, eps) t_0 = Float64(sin(Float64(x + eps)) - sin(x)) tmp = 0.0 if ((t_0 <= -0.02) || !(t_0 <= 5e-141)) tmp = t_0; else tmp = Float64(cos(x) * Float64(2.0 * sin(Float64(eps * 0.5)))); end return tmp end
function tmp_2 = code(x, eps) t_0 = sin((x + eps)) - sin(x); tmp = 0.0; if ((t_0 <= -0.02) || ~((t_0 <= 5e-141))) tmp = t_0; else tmp = cos(x) * (2.0 * sin((eps * 0.5))); end tmp_2 = tmp; end
code[x_, eps_] := Block[{t$95$0 = N[(N[Sin[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -0.02], N[Not[LessEqual[t$95$0, 5e-141]], $MachinePrecision]], t$95$0, N[(N[Cos[x], $MachinePrecision] * N[(2.0 * N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin \left(x + \varepsilon\right) - \sin x\\
\mathbf{if}\;t_0 \leq -0.02 \lor \neg \left(t_0 \leq 5 \cdot 10^{-141}\right):\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\cos x \cdot \left(2 \cdot \sin \left(\varepsilon \cdot 0.5\right)\right)\\
\end{array}
\end{array}
if (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) < -0.0200000000000000004 or 4.9999999999999999e-141 < (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) Initial program 67.4%
if -0.0200000000000000004 < (-.f64 (sin.f64 (+.f64 x eps)) (sin.f64 x)) < 4.9999999999999999e-141Initial program 20.0%
diff-sin20.0%
div-inv20.0%
associate--l+20.0%
metadata-eval20.0%
div-inv20.0%
+-commutative20.0%
associate-+l+20.0%
metadata-eval20.0%
Applied egg-rr20.0%
associate-*r*20.0%
*-commutative20.0%
*-commutative20.0%
+-commutative20.0%
count-220.0%
fma-def20.0%
sub-neg20.0%
mul-1-neg20.0%
+-commutative20.0%
associate-+r+84.3%
mul-1-neg84.3%
sub-neg84.3%
+-inverses84.3%
remove-double-neg84.3%
mul-1-neg84.3%
sub-neg84.3%
neg-sub084.3%
mul-1-neg84.3%
remove-double-neg84.3%
Simplified84.3%
Taylor expanded in eps around 0 84.3%
Final simplification77.1%
(FPCore (x eps) :precision binary64 (fma (sin eps) (cos x) (* (sin x) (+ -1.0 (cos eps)))))
double code(double x, double eps) {
return fma(sin(eps), cos(x), (sin(x) * (-1.0 + cos(eps))));
}
function code(x, eps) return fma(sin(eps), cos(x), Float64(sin(x) * Float64(-1.0 + cos(eps)))) end
code[x_, eps_] := N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision] + N[(N[Sin[x], $MachinePrecision] * N[(-1.0 + N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\sin \varepsilon, \cos x, \sin x \cdot \left(-1 + \cos \varepsilon\right)\right)
\end{array}
Initial program 40.4%
sin-sum63.7%
associate--l+63.6%
Applied egg-rr63.6%
+-commutative63.6%
associate-+l-99.4%
*-commutative99.4%
*-rgt-identity99.4%
distribute-lft-out--99.3%
Simplified99.3%
Taylor expanded in eps around inf 99.3%
sub-neg99.3%
distribute-rgt-neg-out99.3%
*-commutative99.3%
+-commutative99.3%
fma-def99.4%
sub-neg99.4%
+-commutative99.4%
distribute-neg-in99.4%
remove-double-neg99.4%
metadata-eval99.4%
*-commutative99.4%
Simplified99.4%
Taylor expanded in x around inf 99.3%
sub-neg99.3%
metadata-eval99.3%
*-commutative99.3%
fma-def99.4%
Simplified99.4%
Final simplification99.4%
(FPCore (x eps) :precision binary64 (- (* (sin eps) (cos x)) (/ (sin x) (/ 1.0 (- 1.0 (cos eps))))))
double code(double x, double eps) {
return (sin(eps) * cos(x)) - (sin(x) / (1.0 / (1.0 - cos(eps))));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = (sin(eps) * cos(x)) - (sin(x) / (1.0d0 / (1.0d0 - cos(eps))))
end function
public static double code(double x, double eps) {
return (Math.sin(eps) * Math.cos(x)) - (Math.sin(x) / (1.0 / (1.0 - Math.cos(eps))));
}
def code(x, eps): return (math.sin(eps) * math.cos(x)) - (math.sin(x) / (1.0 / (1.0 - math.cos(eps))))
function code(x, eps) return Float64(Float64(sin(eps) * cos(x)) - Float64(sin(x) / Float64(1.0 / Float64(1.0 - cos(eps))))) end
function tmp = code(x, eps) tmp = (sin(eps) * cos(x)) - (sin(x) / (1.0 / (1.0 - cos(eps)))); end
code[x_, eps_] := N[(N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[x], $MachinePrecision] / N[(1.0 / N[(1.0 - N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \varepsilon \cdot \cos x - \frac{\sin x}{\frac{1}{1 - \cos \varepsilon}}
\end{array}
Initial program 40.4%
sin-sum63.7%
associate--l+63.6%
Applied egg-rr63.6%
+-commutative63.6%
associate-+l-99.4%
*-commutative99.4%
*-rgt-identity99.4%
distribute-lft-out--99.3%
Simplified99.3%
flip--99.3%
associate-*r/99.3%
metadata-eval99.3%
1-sub-cos99.5%
pow299.5%
Applied egg-rr99.5%
associate-/l*99.5%
Simplified99.5%
expm1-log1p-u99.5%
expm1-udef99.5%
clear-num99.5%
unpow299.5%
1-sub-cos99.2%
metadata-eval99.2%
flip--99.3%
Applied egg-rr99.3%
expm1-def99.3%
expm1-log1p99.4%
Simplified99.4%
Final simplification99.4%
(FPCore (x eps) :precision binary64 (+ (* (sin eps) (cos x)) (* (sin x) (+ -1.0 (cos eps)))))
double code(double x, double eps) {
return (sin(eps) * cos(x)) + (sin(x) * (-1.0 + cos(eps)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = (sin(eps) * cos(x)) + (sin(x) * ((-1.0d0) + cos(eps)))
end function
public static double code(double x, double eps) {
return (Math.sin(eps) * Math.cos(x)) + (Math.sin(x) * (-1.0 + Math.cos(eps)));
}
def code(x, eps): return (math.sin(eps) * math.cos(x)) + (math.sin(x) * (-1.0 + math.cos(eps)))
function code(x, eps) return Float64(Float64(sin(eps) * cos(x)) + Float64(sin(x) * Float64(-1.0 + cos(eps)))) end
function tmp = code(x, eps) tmp = (sin(eps) * cos(x)) + (sin(x) * (-1.0 + cos(eps))); end
code[x_, eps_] := N[(N[(N[Sin[eps], $MachinePrecision] * N[Cos[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[x], $MachinePrecision] * N[(-1.0 + N[Cos[eps], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin \varepsilon \cdot \cos x + \sin x \cdot \left(-1 + \cos \varepsilon\right)
\end{array}
Initial program 40.4%
sin-sum63.7%
associate--l+63.6%
Applied egg-rr63.6%
+-commutative63.6%
associate-+l-99.4%
*-commutative99.4%
*-rgt-identity99.4%
distribute-lft-out--99.3%
Simplified99.3%
Final simplification99.3%
(FPCore (x eps) :precision binary64 (* 2.0 (* (sin (/ (+ eps (- x x)) 2.0)) (cos (/ (+ x (+ x eps)) 2.0)))))
double code(double x, double eps) {
return 2.0 * (sin(((eps + (x - x)) / 2.0)) * cos(((x + (x + eps)) / 2.0)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = 2.0d0 * (sin(((eps + (x - x)) / 2.0d0)) * cos(((x + (x + eps)) / 2.0d0)))
end function
public static double code(double x, double eps) {
return 2.0 * (Math.sin(((eps + (x - x)) / 2.0)) * Math.cos(((x + (x + eps)) / 2.0)));
}
def code(x, eps): return 2.0 * (math.sin(((eps + (x - x)) / 2.0)) * math.cos(((x + (x + eps)) / 2.0)))
function code(x, eps) return Float64(2.0 * Float64(sin(Float64(Float64(eps + Float64(x - x)) / 2.0)) * cos(Float64(Float64(x + Float64(x + eps)) / 2.0)))) end
function tmp = code(x, eps) tmp = 2.0 * (sin(((eps + (x - x)) / 2.0)) * cos(((x + (x + eps)) / 2.0))); end
code[x_, eps_] := N[(2.0 * N[(N[Sin[N[(N[(eps + N[(x - x), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(N[(x + N[(x + eps), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\sin \left(\frac{\varepsilon + \left(x - x\right)}{2}\right) \cdot \cos \left(\frac{x + \left(x + \varepsilon\right)}{2}\right)\right)
\end{array}
Initial program 40.4%
add-cbrt-cube32.6%
pow332.7%
Applied egg-rr32.7%
rem-cbrt-cube40.4%
diff-sin39.9%
+-commutative39.9%
+-commutative39.9%
Applied egg-rr39.9%
associate--l+76.7%
+-commutative76.7%
Simplified76.7%
Final simplification76.7%
(FPCore (x eps) :precision binary64 (* (cos (/ (+ eps (* x 2.0)) 2.0)) (* 2.0 (sin (/ eps 2.0)))))
double code(double x, double eps) {
return cos(((eps + (x * 2.0)) / 2.0)) * (2.0 * sin((eps / 2.0)));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = cos(((eps + (x * 2.0d0)) / 2.0d0)) * (2.0d0 * sin((eps / 2.0d0)))
end function
public static double code(double x, double eps) {
return Math.cos(((eps + (x * 2.0)) / 2.0)) * (2.0 * Math.sin((eps / 2.0)));
}
def code(x, eps): return math.cos(((eps + (x * 2.0)) / 2.0)) * (2.0 * math.sin((eps / 2.0)))
function code(x, eps) return Float64(cos(Float64(Float64(eps + Float64(x * 2.0)) / 2.0)) * Float64(2.0 * sin(Float64(eps / 2.0)))) end
function tmp = code(x, eps) tmp = cos(((eps + (x * 2.0)) / 2.0)) * (2.0 * sin((eps / 2.0))); end
code[x_, eps_] := N[(N[Cos[N[(N[(eps + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[Sin[N[(eps / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos \left(\frac{\varepsilon + x \cdot 2}{2}\right) \cdot \left(2 \cdot \sin \left(\frac{\varepsilon}{2}\right)\right)
\end{array}
Initial program 40.4%
log1p-expm1-u40.3%
Applied egg-rr40.3%
log1p-expm1-u40.4%
diff-sin39.9%
+-commutative39.9%
+-commutative39.9%
Applied egg-rr39.9%
associate-*r*39.9%
*-commutative39.9%
associate-+l+39.9%
count-239.9%
associate--l+76.6%
+-inverses76.6%
Simplified76.6%
Final simplification76.6%
(FPCore (x eps) :precision binary64 (if (or (<= eps -3e-5) (not (<= eps 1.12e-7))) (sin eps) (* eps (cos x))))
double code(double x, double eps) {
double tmp;
if ((eps <= -3e-5) || !(eps <= 1.12e-7)) {
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 <= (-3d-5)) .or. (.not. (eps <= 1.12d-7))) 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 <= -3e-5) || !(eps <= 1.12e-7)) {
tmp = Math.sin(eps);
} else {
tmp = eps * Math.cos(x);
}
return tmp;
}
def code(x, eps): tmp = 0 if (eps <= -3e-5) or not (eps <= 1.12e-7): tmp = math.sin(eps) else: tmp = eps * math.cos(x) return tmp
function code(x, eps) tmp = 0.0 if ((eps <= -3e-5) || !(eps <= 1.12e-7)) tmp = sin(eps); else tmp = Float64(eps * cos(x)); end return tmp end
function tmp_2 = code(x, eps) tmp = 0.0; if ((eps <= -3e-5) || ~((eps <= 1.12e-7))) tmp = sin(eps); else tmp = eps * cos(x); end tmp_2 = tmp; end
code[x_, eps_] := If[Or[LessEqual[eps, -3e-5], N[Not[LessEqual[eps, 1.12e-7]], $MachinePrecision]], N[Sin[eps], $MachinePrecision], N[(eps * N[Cos[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\varepsilon \leq -3 \cdot 10^{-5} \lor \neg \left(\varepsilon \leq 1.12 \cdot 10^{-7}\right):\\
\;\;\;\;\sin \varepsilon\\
\mathbf{else}:\\
\;\;\;\;\varepsilon \cdot \cos x\\
\end{array}
\end{array}
if eps < -3.00000000000000008e-5 or 1.12e-7 < eps Initial program 52.8%
Taylor expanded in x around 0 53.4%
if -3.00000000000000008e-5 < eps < 1.12e-7Initial program 28.6%
Taylor expanded in eps around 0 99.4%
Final simplification77.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 40.4%
Taylor expanded in x around 0 52.7%
Final simplification52.7%
(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.4%
Taylor expanded in eps around 0 53.1%
Taylor expanded in x around 0 28.7%
Final simplification28.7%
(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 2023334
(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)))