2cos (problem 3.3.5)

Percentage Accurate: 37.7% → 99.3%

Time: 20.9s

Alternatives: 16

Speedup: 1.9×

Specification

Math

\[\begin{array}{l} \\ \cos \left(x + \varepsilon\right) - \cos x \end{array} \]

FPCore

(FPCore (x eps) :precision binary64 (- (cos (+ x eps)) (cos x)))

C

double code(double x, double eps) {
	return cos((x + eps)) - cos(x);
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = cos((x + eps)) - cos(x)
end function

Java

public static double code(double x, double eps) {
	return Math.cos((x + eps)) - Math.cos(x);
}

Python

def code(x, eps):
	return math.cos((x + eps)) - math.cos(x)

Julia

function code(x, eps)
	return Float64(cos(Float64(x + eps)) - cos(x))
end

MATLAB

function tmp = code(x, eps)
	tmp = cos((x + eps)) - cos(x);
end

Wolfram

code[x_, eps_] := N[(N[Cos[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Cos[x], $MachinePrecision]), $MachinePrecision]

Initial Program: 37.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \cos \left(x + \varepsilon\right) - \cos x \end{array} \]

FPCore

(FPCore (x eps) :precision binary64 (- (cos (+ x eps)) (cos x)))

C

double code(double x, double eps) {
	return cos((x + eps)) - cos(x);
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = cos((x + eps)) - cos(x)
end function

Java

public static double code(double x, double eps) {
	return Math.cos((x + eps)) - Math.cos(x);
}

Python

def code(x, eps):
	return math.cos((x + eps)) - math.cos(x)

Julia

function code(x, eps)
	return Float64(cos(Float64(x + eps)) - cos(x))
end

MATLAB

function tmp = code(x, eps)
	tmp = cos((x + eps)) - cos(x);
end

Wolfram

code[x_, eps_] := N[(N[Cos[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Cos[x], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.3% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.031:\\ \;\;\;\;\mathsf{fma}\left(-\sin \varepsilon, \sin x, t_1\right) + \left(\cos x \cdot t_0 - t_1\right)\\ \mathbf{elif}\;\varepsilon \leq 0.027:\\ \;\;\;\;\cos x \cdot \left(-0.5 \cdot {\varepsilon}^{2} + \left(-0.001388888888888889 \cdot {\varepsilon}^{6} + 0.041666666666666664 \cdot {\varepsilon}^{4}\right)\right) - t_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(t_0, \cos x, \sin \varepsilon \cdot \left(-\sin x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* (sin eps) (sin x))))
   (if (<= eps -0.031)
     (+ (fma (- (sin eps)) (sin x) t_1) (- (* (cos x) t_0) t_1))
     (if (<= eps 0.027)
       (-
        (*
         (cos x)
         (+
          (* -0.5 (pow eps 2.0))
          (+
           (* -0.001388888888888889 (pow eps 6.0))
           (* 0.041666666666666664 (pow eps 4.0)))))
        t_1)
       (fma t_0 (cos x) (* (sin eps) (- (sin x))))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = sin(eps) * sin(x);
	double tmp;
	if (eps <= -0.031) {
		tmp = fma(-sin(eps), sin(x), t_1) + ((cos(x) * t_0) - t_1);
	} else if (eps <= 0.027) {
		tmp = (cos(x) * ((-0.5 * pow(eps, 2.0)) + ((-0.001388888888888889 * pow(eps, 6.0)) + (0.041666666666666664 * pow(eps, 4.0))))) - t_1;
	} else {
		tmp = fma(t_0, cos(x), (sin(eps) * -sin(x)));
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if (eps <= -0.031)
		tmp = Float64(fma(Float64(-sin(eps)), sin(x), t_1) + Float64(Float64(cos(x) * t_0) - t_1));
	elseif (eps <= 0.027)
		tmp = Float64(Float64(cos(x) * Float64(Float64(-0.5 * (eps ^ 2.0)) + Float64(Float64(-0.001388888888888889 * (eps ^ 6.0)) + Float64(0.041666666666666664 * (eps ^ 4.0))))) - t_1);
	else
		tmp = fma(t_0, cos(x), Float64(sin(eps) * Float64(-sin(x))));
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.031], N[(N[((-N[Sin[eps], $MachinePrecision]) * N[Sin[x], $MachinePrecision] + t$95$1), $MachinePrecision] + N[(N[(N[Cos[x], $MachinePrecision] * t$95$0), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[eps, 0.027], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-0.001388888888888889 * N[Power[eps, 6.0], $MachinePrecision]), $MachinePrecision] + N[(0.041666666666666664 * N[Power[eps, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$0 * N[Cos[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 99.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \varepsilon \cdot \left(-\sin x\right)\\ \mathbf{if}\;\varepsilon \leq -0.032:\\ \;\;\;\;\mathsf{fma}\left(\frac{-1 + {\cos \varepsilon}^{3}}{1 + \cos \varepsilon \cdot \left(\cos \varepsilon - -1\right)}, \cos x, t_0\right)\\ \mathbf{elif}\;\varepsilon \leq 0.027:\\ \;\;\;\;\cos x \cdot \left(-0.5 \cdot {\varepsilon}^{2} + \left(-0.001388888888888889 \cdot {\varepsilon}^{6} + 0.041666666666666664 \cdot {\varepsilon}^{4}\right)\right) - \sin \varepsilon \cdot \sin x\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(\cos \varepsilon + -1, \cos x, t_0\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (* (sin eps) (- (sin x)))))
   (if (<= eps -0.032)
     (fma
      (/ (+ -1.0 (pow (cos eps) 3.0)) (+ 1.0 (* (cos eps) (- (cos eps) -1.0))))
      (cos x)
      t_0)
     (if (<= eps 0.027)
       (-
        (*
         (cos x)
         (+
          (* -0.5 (pow eps 2.0))
          (+
           (* -0.001388888888888889 (pow eps 6.0))
           (* 0.041666666666666664 (pow eps 4.0)))))
        (* (sin eps) (sin x)))
       (fma (+ (cos eps) -1.0) (cos x) t_0)))))

C

double code(double x, double eps) {
	double t_0 = sin(eps) * -sin(x);
	double tmp;
	if (eps <= -0.032) {
		tmp = fma(((-1.0 + pow(cos(eps), 3.0)) / (1.0 + (cos(eps) * (cos(eps) - -1.0)))), cos(x), t_0);
	} else if (eps <= 0.027) {
		tmp = (cos(x) * ((-0.5 * pow(eps, 2.0)) + ((-0.001388888888888889 * pow(eps, 6.0)) + (0.041666666666666664 * pow(eps, 4.0))))) - (sin(eps) * sin(x));
	} else {
		tmp = fma((cos(eps) + -1.0), cos(x), t_0);
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(sin(eps) * Float64(-sin(x)))
	tmp = 0.0
	if (eps <= -0.032)
		tmp = fma(Float64(Float64(-1.0 + (cos(eps) ^ 3.0)) / Float64(1.0 + Float64(cos(eps) * Float64(cos(eps) - -1.0)))), cos(x), t_0);
	elseif (eps <= 0.027)
		tmp = Float64(Float64(cos(x) * Float64(Float64(-0.5 * (eps ^ 2.0)) + Float64(Float64(-0.001388888888888889 * (eps ^ 6.0)) + Float64(0.041666666666666664 * (eps ^ 4.0))))) - Float64(sin(eps) * sin(x)));
	else
		tmp = fma(Float64(cos(eps) + -1.0), cos(x), t_0);
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]}, If[LessEqual[eps, -0.032], N[(N[(N[(-1.0 + N[Power[N[Cos[eps], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[Cos[eps], $MachinePrecision] * N[(N[Cos[eps], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[x], $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[eps, 0.027], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-0.001388888888888889 * N[Power[eps, 6.0], $MachinePrecision]), $MachinePrecision] + N[(0.041666666666666664 * N[Power[eps, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision] * N[Cos[x], $MachinePrecision] + t$95$0), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 99.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.031:\\ \;\;\;\;\cos x \cdot t_0 - \mathsf{expm1}\left(\mathsf{log1p}\left(t_1\right)\right)\\ \mathbf{elif}\;\varepsilon \leq 0.027:\\ \;\;\;\;\cos x \cdot \left(-0.5 \cdot {\varepsilon}^{2} + \left(-0.001388888888888889 \cdot {\varepsilon}^{6} + 0.041666666666666664 \cdot {\varepsilon}^{4}\right)\right) - t_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(t_0, \cos x, \sin \varepsilon \cdot \left(-\sin x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* (sin eps) (sin x))))
   (if (<= eps -0.031)
     (- (* (cos x) t_0) (expm1 (log1p t_1)))
     (if (<= eps 0.027)
       (-
        (*
         (cos x)
         (+
          (* -0.5 (pow eps 2.0))
          (+
           (* -0.001388888888888889 (pow eps 6.0))
           (* 0.041666666666666664 (pow eps 4.0)))))
        t_1)
       (fma t_0 (cos x) (* (sin eps) (- (sin x))))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = sin(eps) * sin(x);
	double tmp;
	if (eps <= -0.031) {
		tmp = (cos(x) * t_0) - expm1(log1p(t_1));
	} else if (eps <= 0.027) {
		tmp = (cos(x) * ((-0.5 * pow(eps, 2.0)) + ((-0.001388888888888889 * pow(eps, 6.0)) + (0.041666666666666664 * pow(eps, 4.0))))) - t_1;
	} else {
		tmp = fma(t_0, cos(x), (sin(eps) * -sin(x)));
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if (eps <= -0.031)
		tmp = Float64(Float64(cos(x) * t_0) - expm1(log1p(t_1)));
	elseif (eps <= 0.027)
		tmp = Float64(Float64(cos(x) * Float64(Float64(-0.5 * (eps ^ 2.0)) + Float64(Float64(-0.001388888888888889 * (eps ^ 6.0)) + Float64(0.041666666666666664 * (eps ^ 4.0))))) - t_1);
	else
		tmp = fma(t_0, cos(x), Float64(sin(eps) * Float64(-sin(x))));
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.031], N[(N[(N[Cos[x], $MachinePrecision] * t$95$0), $MachinePrecision] - N[(Exp[N[Log[1 + t$95$1], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], If[LessEqual[eps, 0.027], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-0.001388888888888889 * N[Power[eps, 6.0], $MachinePrecision]), $MachinePrecision] + N[(0.041666666666666664 * N[Power[eps, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$0 * N[Cos[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 99.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.0056:\\ \;\;\;\;\cos x \cdot t_0 - \mathsf{expm1}\left(\mathsf{log1p}\left(t_1\right)\right)\\ \mathbf{elif}\;\varepsilon \leq 0.0049:\\ \;\;\;\;\cos x \cdot \left(-0.5 \cdot {\varepsilon}^{2} + 0.041666666666666664 \cdot {\varepsilon}^{4}\right) - t_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(t_0, \cos x, \sin \varepsilon \cdot \left(-\sin x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* (sin eps) (sin x))))
   (if (<= eps -0.0056)
     (- (* (cos x) t_0) (expm1 (log1p t_1)))
     (if (<= eps 0.0049)
       (-
        (*
         (cos x)
         (+ (* -0.5 (pow eps 2.0)) (* 0.041666666666666664 (pow eps 4.0))))
        t_1)
       (fma t_0 (cos x) (* (sin eps) (- (sin x))))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = sin(eps) * sin(x);
	double tmp;
	if (eps <= -0.0056) {
		tmp = (cos(x) * t_0) - expm1(log1p(t_1));
	} else if (eps <= 0.0049) {
		tmp = (cos(x) * ((-0.5 * pow(eps, 2.0)) + (0.041666666666666664 * pow(eps, 4.0)))) - t_1;
	} else {
		tmp = fma(t_0, cos(x), (sin(eps) * -sin(x)));
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if (eps <= -0.0056)
		tmp = Float64(Float64(cos(x) * t_0) - expm1(log1p(t_1)));
	elseif (eps <= 0.0049)
		tmp = Float64(Float64(cos(x) * Float64(Float64(-0.5 * (eps ^ 2.0)) + Float64(0.041666666666666664 * (eps ^ 4.0)))) - t_1);
	else
		tmp = fma(t_0, cos(x), Float64(sin(eps) * Float64(-sin(x))));
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.0056], N[(N[(N[Cos[x], $MachinePrecision] * t$95$0), $MachinePrecision] - N[(Exp[N[Log[1 + t$95$1], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], If[LessEqual[eps, 0.0049], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision] + N[(0.041666666666666664 * N[Power[eps, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$0 * N[Cos[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 99.3% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.0056:\\ \;\;\;\;\cos x \cdot t_0 - t_1\\ \mathbf{elif}\;\varepsilon \leq 0.0049:\\ \;\;\;\;\cos x \cdot \left(-0.5 \cdot {\varepsilon}^{2} + 0.041666666666666664 \cdot {\varepsilon}^{4}\right) - t_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(t_0, \cos x, \sin \varepsilon \cdot \left(-\sin x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* (sin eps) (sin x))))
   (if (<= eps -0.0056)
     (- (* (cos x) t_0) t_1)
     (if (<= eps 0.0049)
       (-
        (*
         (cos x)
         (+ (* -0.5 (pow eps 2.0)) (* 0.041666666666666664 (pow eps 4.0))))
        t_1)
       (fma t_0 (cos x) (* (sin eps) (- (sin x))))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = sin(eps) * sin(x);
	double tmp;
	if (eps <= -0.0056) {
		tmp = (cos(x) * t_0) - t_1;
	} else if (eps <= 0.0049) {
		tmp = (cos(x) * ((-0.5 * pow(eps, 2.0)) + (0.041666666666666664 * pow(eps, 4.0)))) - t_1;
	} else {
		tmp = fma(t_0, cos(x), (sin(eps) * -sin(x)));
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if (eps <= -0.0056)
		tmp = Float64(Float64(cos(x) * t_0) - t_1);
	elseif (eps <= 0.0049)
		tmp = Float64(Float64(cos(x) * Float64(Float64(-0.5 * (eps ^ 2.0)) + Float64(0.041666666666666664 * (eps ^ 4.0)))) - t_1);
	else
		tmp = fma(t_0, cos(x), Float64(sin(eps) * Float64(-sin(x))));
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.0056], N[(N[(N[Cos[x], $MachinePrecision] * t$95$0), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[eps, 0.0049], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision] + N[(0.041666666666666664 * N[Power[eps, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$0 * N[Cos[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 99.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.000115:\\ \;\;\;\;\cos x \cdot t_0 - t_1\\ \mathbf{elif}\;\varepsilon \leq 0.000125:\\ \;\;\;\;{\varepsilon}^{2} \cdot \left(\cos x \cdot -0.5\right) - t_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(t_0, \cos x, \sin \varepsilon \cdot \left(-\sin x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* (sin eps) (sin x))))
   (if (<= eps -0.000115)
     (- (* (cos x) t_0) t_1)
     (if (<= eps 0.000125)
       (- (* (pow eps 2.0) (* (cos x) -0.5)) t_1)
       (fma t_0 (cos x) (* (sin eps) (- (sin x))))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = sin(eps) * sin(x);
	double tmp;
	if (eps <= -0.000115) {
		tmp = (cos(x) * t_0) - t_1;
	} else if (eps <= 0.000125) {
		tmp = (pow(eps, 2.0) * (cos(x) * -0.5)) - t_1;
	} else {
		tmp = fma(t_0, cos(x), (sin(eps) * -sin(x)));
	}
	return tmp;
}

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if (eps <= -0.000115)
		tmp = Float64(Float64(cos(x) * t_0) - t_1);
	elseif (eps <= 0.000125)
		tmp = Float64(Float64((eps ^ 2.0) * Float64(cos(x) * -0.5)) - t_1);
	else
		tmp = fma(t_0, cos(x), Float64(sin(eps) * Float64(-sin(x))));
	end
	return tmp
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.000115], N[(N[(N[Cos[x], $MachinePrecision] * t$95$0), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[eps, 0.000125], N[(N[(N[Power[eps, 2.0], $MachinePrecision] * N[(N[Cos[x], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$0 * N[Cos[x], $MachinePrecision] + N[(N[Sin[eps], $MachinePrecision] * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 99.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \varepsilon \cdot \sin x\\ \mathbf{if}\;\varepsilon \leq -0.000115 \lor \neg \left(\varepsilon \leq 0.000125\right):\\ \;\;\;\;\cos x \cdot \left(\cos \varepsilon + -1\right) - t_0\\ \mathbf{else}:\\ \;\;\;\;{\varepsilon}^{2} \cdot \left(\cos x \cdot -0.5\right) - t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (* (sin eps) (sin x))))
   (if (or (<= eps -0.000115) (not (<= eps 0.000125)))
     (- (* (cos x) (+ (cos eps) -1.0)) t_0)
     (- (* (pow eps 2.0) (* (cos x) -0.5)) t_0))))

C

double code(double x, double eps) {
	double t_0 = sin(eps) * sin(x);
	double tmp;
	if ((eps <= -0.000115) || !(eps <= 0.000125)) {
		tmp = (cos(x) * (cos(eps) + -1.0)) - t_0;
	} else {
		tmp = (pow(eps, 2.0) * (cos(x) * -0.5)) - t_0;
	}
	return tmp;
}

Fortran

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) * sin(x)
    if ((eps <= (-0.000115d0)) .or. (.not. (eps <= 0.000125d0))) then
        tmp = (cos(x) * (cos(eps) + (-1.0d0))) - t_0
    else
        tmp = ((eps ** 2.0d0) * (cos(x) * (-0.5d0))) - t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double t_0 = Math.sin(eps) * Math.sin(x);
	double tmp;
	if ((eps <= -0.000115) || !(eps <= 0.000125)) {
		tmp = (Math.cos(x) * (Math.cos(eps) + -1.0)) - t_0;
	} else {
		tmp = (Math.pow(eps, 2.0) * (Math.cos(x) * -0.5)) - t_0;
	}
	return tmp;
}

Python

def code(x, eps):
	t_0 = math.sin(eps) * math.sin(x)
	tmp = 0
	if (eps <= -0.000115) or not (eps <= 0.000125):
		tmp = (math.cos(x) * (math.cos(eps) + -1.0)) - t_0
	else:
		tmp = (math.pow(eps, 2.0) * (math.cos(x) * -0.5)) - t_0
	return tmp

Julia

function code(x, eps)
	t_0 = Float64(sin(eps) * sin(x))
	tmp = 0.0
	if ((eps <= -0.000115) || !(eps <= 0.000125))
		tmp = Float64(Float64(cos(x) * Float64(cos(eps) + -1.0)) - t_0);
	else
		tmp = Float64(Float64((eps ^ 2.0) * Float64(cos(x) * -0.5)) - t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	t_0 = sin(eps) * sin(x);
	tmp = 0.0;
	if ((eps <= -0.000115) || ~((eps <= 0.000125)))
		tmp = (cos(x) * (cos(eps) + -1.0)) - t_0;
	else
		tmp = ((eps ^ 2.0) * (cos(x) * -0.5)) - t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[eps, -0.000115], N[Not[LessEqual[eps, 0.000125]], $MachinePrecision]], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(N[Power[eps, 2.0], $MachinePrecision] * N[(N[Cos[x], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 99.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\varepsilon \leq -1.1 \cdot 10^{-5} \lor \neg \left(\varepsilon \leq 2.9 \cdot 10^{-5}\right):\\ \;\;\;\;\cos x \cdot \left(\cos \varepsilon + -1\right) - \sin \varepsilon \cdot \sin x\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\cos x \cdot {\varepsilon}^{2}\right) - \varepsilon \cdot \sin x\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (if (or (<= eps -1.1e-5) (not (<= eps 2.9e-5)))
   (- (* (cos x) (+ (cos eps) -1.0)) (* (sin eps) (sin x)))
   (- (* -0.5 (* (cos x) (pow eps 2.0))) (* eps (sin x)))))

C

double code(double x, double eps) {
	double tmp;
	if ((eps <= -1.1e-5) || !(eps <= 2.9e-5)) {
		tmp = (cos(x) * (cos(eps) + -1.0)) - (sin(eps) * sin(x));
	} else {
		tmp = (-0.5 * (cos(x) * pow(eps, 2.0))) - (eps * sin(x));
	}
	return tmp;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    real(8) :: tmp
    if ((eps <= (-1.1d-5)) .or. (.not. (eps <= 2.9d-5))) then
        tmp = (cos(x) * (cos(eps) + (-1.0d0))) - (sin(eps) * sin(x))
    else
        tmp = ((-0.5d0) * (cos(x) * (eps ** 2.0d0))) - (eps * sin(x))
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double tmp;
	if ((eps <= -1.1e-5) || !(eps <= 2.9e-5)) {
		tmp = (Math.cos(x) * (Math.cos(eps) + -1.0)) - (Math.sin(eps) * Math.sin(x));
	} else {
		tmp = (-0.5 * (Math.cos(x) * Math.pow(eps, 2.0))) - (eps * Math.sin(x));
	}
	return tmp;
}

Python

def code(x, eps):
	tmp = 0
	if (eps <= -1.1e-5) or not (eps <= 2.9e-5):
		tmp = (math.cos(x) * (math.cos(eps) + -1.0)) - (math.sin(eps) * math.sin(x))
	else:
		tmp = (-0.5 * (math.cos(x) * math.pow(eps, 2.0))) - (eps * math.sin(x))
	return tmp

Julia

function code(x, eps)
	tmp = 0.0
	if ((eps <= -1.1e-5) || !(eps <= 2.9e-5))
		tmp = Float64(Float64(cos(x) * Float64(cos(eps) + -1.0)) - Float64(sin(eps) * sin(x)));
	else
		tmp = Float64(Float64(-0.5 * Float64(cos(x) * (eps ^ 2.0))) - Float64(eps * sin(x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	tmp = 0.0;
	if ((eps <= -1.1e-5) || ~((eps <= 2.9e-5)))
		tmp = (cos(x) * (cos(eps) + -1.0)) - (sin(eps) * sin(x));
	else
		tmp = (-0.5 * (cos(x) * (eps ^ 2.0))) - (eps * sin(x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := If[Or[LessEqual[eps, -1.1e-5], N[Not[LessEqual[eps, 2.9e-5]], $MachinePrecision]], N[(N[(N[Cos[x], $MachinePrecision] * N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] - N[(N[Sin[eps], $MachinePrecision] * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(-0.5 * N[(N[Cos[x], $MachinePrecision] * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(eps * N[Sin[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 75.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \sin \left(0.5 \cdot \left(\varepsilon + x \cdot 2\right)\right) \cdot \left(-2 \cdot \sin \left(\varepsilon \cdot 0.5\right)\right) \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (* (sin (* 0.5 (+ eps (* x 2.0)))) (* -2.0 (sin (* eps 0.5)))))

C

double code(double x, double eps) {
	return sin((0.5 * (eps + (x * 2.0)))) * (-2.0 * sin((eps * 0.5)));
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = sin((0.5d0 * (eps + (x * 2.0d0)))) * ((-2.0d0) * sin((eps * 0.5d0)))
end function

Java

public static double code(double x, double eps) {
	return Math.sin((0.5 * (eps + (x * 2.0)))) * (-2.0 * Math.sin((eps * 0.5)));
}

Python

def code(x, eps):
	return math.sin((0.5 * (eps + (x * 2.0)))) * (-2.0 * math.sin((eps * 0.5)))

Julia

function code(x, eps)
	return Float64(sin(Float64(0.5 * Float64(eps + Float64(x * 2.0)))) * Float64(-2.0 * sin(Float64(eps * 0.5))))
end

MATLAB

function tmp = code(x, eps)
	tmp = sin((0.5 * (eps + (x * 2.0)))) * (-2.0 * sin((eps * 0.5)));
end

Wolfram

code[x_, eps_] := N[(N[Sin[N[(0.5 * N[(eps + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(-2.0 * N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 75.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ -2 \cdot \left(\sin \left(\varepsilon \cdot 0.5\right) \cdot \sin \left(x + \varepsilon \cdot 0.5\right)\right) \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (* -2.0 (* (sin (* eps 0.5)) (sin (+ x (* eps 0.5))))))

C

double code(double x, double eps) {
	return -2.0 * (sin((eps * 0.5)) * sin((x + (eps * 0.5))));
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = (-2.0d0) * (sin((eps * 0.5d0)) * sin((x + (eps * 0.5d0))))
end function

Java

public static double code(double x, double eps) {
	return -2.0 * (Math.sin((eps * 0.5)) * Math.sin((x + (eps * 0.5))));
}

Python

def code(x, eps):
	return -2.0 * (math.sin((eps * 0.5)) * math.sin((x + (eps * 0.5))))

Julia

function code(x, eps)
	return Float64(-2.0 * Float64(sin(Float64(eps * 0.5)) * sin(Float64(x + Float64(eps * 0.5)))))
end

MATLAB

function tmp = code(x, eps)
	tmp = -2.0 * (sin((eps * 0.5)) * sin((x + (eps * 0.5))));
end

Wolfram

code[x_, eps_] := N[(-2.0 * N[(N[Sin[N[(eps * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(x + N[(eps * 0.5), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 66.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\varepsilon \leq -0.0082 \lor \neg \left(\varepsilon \leq 7.5 \cdot 10^{-8}\right):\\ \;\;\;\;\cos \varepsilon - \cos x\\ \mathbf{else}:\\ \;\;\;\;\varepsilon \cdot \left(-\sin x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (if (or (<= eps -0.0082) (not (<= eps 7.5e-8)))
   (- (cos eps) (cos x))
   (* eps (- (sin x)))))

C

double code(double x, double eps) {
	double tmp;
	if ((eps <= -0.0082) || !(eps <= 7.5e-8)) {
		tmp = cos(eps) - cos(x);
	} else {
		tmp = eps * -sin(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    real(8) :: tmp
    if ((eps <= (-0.0082d0)) .or. (.not. (eps <= 7.5d-8))) then
        tmp = cos(eps) - cos(x)
    else
        tmp = eps * -sin(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double tmp;
	if ((eps <= -0.0082) || !(eps <= 7.5e-8)) {
		tmp = Math.cos(eps) - Math.cos(x);
	} else {
		tmp = eps * -Math.sin(x);
	}
	return tmp;
}

Python

def code(x, eps):
	tmp = 0
	if (eps <= -0.0082) or not (eps <= 7.5e-8):
		tmp = math.cos(eps) - math.cos(x)
	else:
		tmp = eps * -math.sin(x)
	return tmp

Julia

function code(x, eps)
	tmp = 0.0
	if ((eps <= -0.0082) || !(eps <= 7.5e-8))
		tmp = Float64(cos(eps) - cos(x));
	else
		tmp = Float64(eps * Float64(-sin(x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	tmp = 0.0;
	if ((eps <= -0.0082) || ~((eps <= 7.5e-8)))
		tmp = cos(eps) - cos(x);
	else
		tmp = eps * -sin(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := If[Or[LessEqual[eps, -0.0082], N[Not[LessEqual[eps, 7.5e-8]], $MachinePrecision]], N[(N[Cos[eps], $MachinePrecision] - N[Cos[x], $MachinePrecision]), $MachinePrecision], N[(eps * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 47.9% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \varepsilon + -1\\ t_1 := -0.5 \cdot {\varepsilon}^{2}\\ \mathbf{if}\;\varepsilon \leq -0.0082:\\ \;\;\;\;t_0\\ \mathbf{elif}\;\varepsilon \leq 9.5 \cdot 10^{-269}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;\varepsilon \leq 1.2 \cdot 10^{-139}:\\ \;\;\;\;\varepsilon \cdot \left(-x\right)\\ \mathbf{elif}\;\varepsilon \leq 0.000125:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (let* ((t_0 (+ (cos eps) -1.0)) (t_1 (* -0.5 (pow eps 2.0))))
   (if (<= eps -0.0082)
     t_0
     (if (<= eps 9.5e-269)
       t_1
       (if (<= eps 1.2e-139) (* eps (- x)) (if (<= eps 0.000125) t_1 t_0))))))

C

double code(double x, double eps) {
	double t_0 = cos(eps) + -1.0;
	double t_1 = -0.5 * pow(eps, 2.0);
	double tmp;
	if (eps <= -0.0082) {
		tmp = t_0;
	} else if (eps <= 9.5e-269) {
		tmp = t_1;
	} else if (eps <= 1.2e-139) {
		tmp = eps * -x;
	} else if (eps <= 0.000125) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = cos(eps) + (-1.0d0)
    t_1 = (-0.5d0) * (eps ** 2.0d0)
    if (eps <= (-0.0082d0)) then
        tmp = t_0
    else if (eps <= 9.5d-269) then
        tmp = t_1
    else if (eps <= 1.2d-139) then
        tmp = eps * -x
    else if (eps <= 0.000125d0) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double t_0 = Math.cos(eps) + -1.0;
	double t_1 = -0.5 * Math.pow(eps, 2.0);
	double tmp;
	if (eps <= -0.0082) {
		tmp = t_0;
	} else if (eps <= 9.5e-269) {
		tmp = t_1;
	} else if (eps <= 1.2e-139) {
		tmp = eps * -x;
	} else if (eps <= 0.000125) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, eps):
	t_0 = math.cos(eps) + -1.0
	t_1 = -0.5 * math.pow(eps, 2.0)
	tmp = 0
	if eps <= -0.0082:
		tmp = t_0
	elif eps <= 9.5e-269:
		tmp = t_1
	elif eps <= 1.2e-139:
		tmp = eps * -x
	elif eps <= 0.000125:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(x, eps)
	t_0 = Float64(cos(eps) + -1.0)
	t_1 = Float64(-0.5 * (eps ^ 2.0))
	tmp = 0.0
	if (eps <= -0.0082)
		tmp = t_0;
	elseif (eps <= 9.5e-269)
		tmp = t_1;
	elseif (eps <= 1.2e-139)
		tmp = Float64(eps * Float64(-x));
	elseif (eps <= 0.000125)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	t_0 = cos(eps) + -1.0;
	t_1 = -0.5 * (eps ^ 2.0);
	tmp = 0.0;
	if (eps <= -0.0082)
		tmp = t_0;
	elseif (eps <= 9.5e-269)
		tmp = t_1;
	elseif (eps <= 1.2e-139)
		tmp = eps * -x;
	elseif (eps <= 0.000125)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := Block[{t$95$0 = N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(-0.5 * N[Power[eps, 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[eps, -0.0082], t$95$0, If[LessEqual[eps, 9.5e-269], t$95$1, If[LessEqual[eps, 1.2e-139], N[(eps * (-x)), $MachinePrecision], If[LessEqual[eps, 0.000125], t$95$1, t$95$0]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 66.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\varepsilon \leq -0.0082 \lor \neg \left(\varepsilon \leq 0.00385\right):\\ \;\;\;\;\cos \varepsilon + -1\\ \mathbf{else}:\\ \;\;\;\;\varepsilon \cdot \left(-\sin x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (if (or (<= eps -0.0082) (not (<= eps 0.00385)))
   (+ (cos eps) -1.0)
   (* eps (- (sin x)))))

C

double code(double x, double eps) {
	double tmp;
	if ((eps <= -0.0082) || !(eps <= 0.00385)) {
		tmp = cos(eps) + -1.0;
	} else {
		tmp = eps * -sin(x);
	}
	return tmp;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    real(8) :: tmp
    if ((eps <= (-0.0082d0)) .or. (.not. (eps <= 0.00385d0))) then
        tmp = cos(eps) + (-1.0d0)
    else
        tmp = eps * -sin(x)
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double tmp;
	if ((eps <= -0.0082) || !(eps <= 0.00385)) {
		tmp = Math.cos(eps) + -1.0;
	} else {
		tmp = eps * -Math.sin(x);
	}
	return tmp;
}

Python

def code(x, eps):
	tmp = 0
	if (eps <= -0.0082) or not (eps <= 0.00385):
		tmp = math.cos(eps) + -1.0
	else:
		tmp = eps * -math.sin(x)
	return tmp

Julia

function code(x, eps)
	tmp = 0.0
	if ((eps <= -0.0082) || !(eps <= 0.00385))
		tmp = Float64(cos(eps) + -1.0);
	else
		tmp = Float64(eps * Float64(-sin(x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	tmp = 0.0;
	if ((eps <= -0.0082) || ~((eps <= 0.00385)))
		tmp = cos(eps) + -1.0;
	else
		tmp = eps * -sin(x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := If[Or[LessEqual[eps, -0.0082], N[Not[LessEqual[eps, 0.00385]], $MachinePrecision]], N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision], N[(eps * (-N[Sin[x], $MachinePrecision])), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 43.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\varepsilon \leq -3.5 \cdot 10^{-9} \lor \neg \left(\varepsilon \leq 1.05 \cdot 10^{-8}\right):\\ \;\;\;\;\cos \varepsilon + -1\\ \mathbf{else}:\\ \;\;\;\;\varepsilon \cdot \left(-x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x eps)
 :precision binary64
 (if (or (<= eps -3.5e-9) (not (<= eps 1.05e-8)))
   (+ (cos eps) -1.0)
   (* eps (- x))))

C

double code(double x, double eps) {
	double tmp;
	if ((eps <= -3.5e-9) || !(eps <= 1.05e-8)) {
		tmp = cos(eps) + -1.0;
	} else {
		tmp = eps * -x;
	}
	return tmp;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    real(8) :: tmp
    if ((eps <= (-3.5d-9)) .or. (.not. (eps <= 1.05d-8))) then
        tmp = cos(eps) + (-1.0d0)
    else
        tmp = eps * -x
    end if
    code = tmp
end function

Java

public static double code(double x, double eps) {
	double tmp;
	if ((eps <= -3.5e-9) || !(eps <= 1.05e-8)) {
		tmp = Math.cos(eps) + -1.0;
	} else {
		tmp = eps * -x;
	}
	return tmp;
}

Python

def code(x, eps):
	tmp = 0
	if (eps <= -3.5e-9) or not (eps <= 1.05e-8):
		tmp = math.cos(eps) + -1.0
	else:
		tmp = eps * -x
	return tmp

Julia

function code(x, eps)
	tmp = 0.0
	if ((eps <= -3.5e-9) || !(eps <= 1.05e-8))
		tmp = Float64(cos(eps) + -1.0);
	else
		tmp = Float64(eps * Float64(-x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, eps)
	tmp = 0.0;
	if ((eps <= -3.5e-9) || ~((eps <= 1.05e-8)))
		tmp = cos(eps) + -1.0;
	else
		tmp = eps * -x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, eps_] := If[Or[LessEqual[eps, -3.5e-9], N[Not[LessEqual[eps, 1.05e-8]], $MachinePrecision]], N[(N[Cos[eps], $MachinePrecision] + -1.0), $MachinePrecision], N[(eps * (-x)), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 18.0% accurate, 51.3× speedup

Math

\[\begin{array}{l} \\ \varepsilon \cdot \left(-x\right) \end{array} \]

FPCore

(FPCore (x eps) :precision binary64 (* eps (- x)))

C

double code(double x, double eps) {
	return eps * -x;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = eps * -x
end function

Java

public static double code(double x, double eps) {
	return eps * -x;
}

Python

def code(x, eps):
	return eps * -x

Julia

function code(x, eps)
	return Float64(eps * Float64(-x))
end

MATLAB

function tmp = code(x, eps)
	tmp = eps * -x;
end

Wolfram

code[x_, eps_] := N[(eps * (-x)), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 12.8% accurate, 205.0× speedup

Math

\[\begin{array}{l} \\ 0 \end{array} \]

FPCore

(FPCore (x eps) :precision binary64 0.0)

C

double code(double x, double eps) {
	return 0.0;
}

Fortran

real(8) function code(x, eps)
    real(8), intent (in) :: x
    real(8), intent (in) :: eps
    code = 0.0d0
end function

Java

public static double code(double x, double eps) {
	return 0.0;
}

Python

def code(x, eps):
	return 0.0

Julia

function code(x, eps)
	return 0.0
end

MATLAB

function tmp = code(x, eps)
	tmp = 0.0;
end

Wolfram

code[x_, eps_] := 0.0

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2024010 
(FPCore (x eps)
  :name "2cos (problem 3.3.5)"
  :precision binary64
  (- (cos (+ x eps)) (cos x)))