ab-angle->ABCF B

Percentage Accurate: 53.2% → 65.4%

Time: 40.8s

Alternatives: 8

Speedup: 5.5×

• 33.6% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \pi \cdot \frac{angle}{180}\\ \left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t_0\right) \cdot \cos t_0 \end{array} \end{array} \]

FPCore

(FPCore (a b angle)
 :precision binary64
 (let* ((t_0 (* PI (/ angle 180.0))))
   (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))

C

double code(double a, double b, double angle) {
	double t_0 = ((double) M_PI) * (angle / 180.0);
	return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}

Java

public static double code(double a, double b, double angle) {
	double t_0 = Math.PI * (angle / 180.0);
	return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}

Python

def code(a, b, angle):
	t_0 = math.pi * (angle / 180.0)
	return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)

Julia

function code(a, b, angle)
	t_0 = Float64(pi * Float64(angle / 180.0))
	return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0))
end

MATLAB

function tmp = code(a, b, angle)
	t_0 = pi * (angle / 180.0);
	tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0);
end

Wolfram

code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]

Initial Program: 53.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \pi \cdot \frac{angle}{180}\\ \left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t_0\right) \cdot \cos t_0 \end{array} \end{array} \]

FPCore

(FPCore (a b angle)
 :precision binary64
 (let* ((t_0 (* PI (/ angle 180.0))))
   (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))

C

double code(double a, double b, double angle) {
	double t_0 = ((double) M_PI) * (angle / 180.0);
	return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}

Java

public static double code(double a, double b, double angle) {
	double t_0 = Math.PI * (angle / 180.0);
	return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}

Python

def code(a, b, angle):
	t_0 = math.pi * (angle / 180.0)
	return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)

Julia

function code(a, b, angle)
	t_0 = Float64(pi * Float64(angle / 180.0))
	return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0))
end

MATLAB

function tmp = code(a, b, angle)
	t_0 = pi * (angle / 180.0);
	tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0);
end

Wolfram

code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]

Alternative 1: 65.4% accurate, 1.5× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ \begin{array}{l} t_0 := \pi \cdot \left(0.005555555555555556 \cdot angle\right)\\ \mathbf{if}\;b_m \leq 10^{+235}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(\left(b_m + a_m\right) \cdot \sin t_0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(\left(b_m + a_m\right) \cdot \sin \left({\left(\sqrt[3]{t_0}\right)}^{3}\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (let* ((t_0 (* PI (* 0.005555555555555556 angle))))
   (if (<= b_m 1e+235)
     (* 2.0 (* (- b_m a_m) (* (+ b_m a_m) (sin t_0))))
     (* 2.0 (* (- b_m a_m) (* (+ b_m a_m) (sin (pow (cbrt t_0) 3.0))))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	double t_0 = ((double) M_PI) * (0.005555555555555556 * angle);
	double tmp;
	if (b_m <= 1e+235) {
		tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin(t_0)));
	} else {
		tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin(pow(cbrt(t_0), 3.0))));
	}
	return tmp;
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	double t_0 = Math.PI * (0.005555555555555556 * angle);
	double tmp;
	if (b_m <= 1e+235) {
		tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * Math.sin(t_0)));
	} else {
		tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * Math.sin(Math.pow(Math.cbrt(t_0), 3.0))));
	}
	return tmp;
}

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	t_0 = Float64(pi * Float64(0.005555555555555556 * angle))
	tmp = 0.0
	if (b_m <= 1e+235)
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(Float64(b_m + a_m) * sin(t_0))));
	else
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(Float64(b_m + a_m) * sin((cbrt(t_0) ^ 3.0)))));
	end
	return tmp
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(Pi * N[(0.005555555555555556 * angle), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b$95$m, 1e+235], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[Sin[N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 3.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 2: 63.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ \begin{array}{l} \mathbf{if}\;{a_m}^{2} \leq 5 \cdot 10^{-239}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(b_m \cdot \sin \left(\pi \cdot \left(0.005555555555555556 \cdot angle\right)\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(0.005555555555555556 \cdot \left(angle \cdot \left(\left(b_m + a_m\right) \cdot \pi\right)\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (if (<= (pow a_m 2.0) 5e-239)
   (* 2.0 (* (- b_m a_m) (* b_m (sin (* PI (* 0.005555555555555556 angle))))))
   (*
    2.0
    (* (- b_m a_m) (* 0.005555555555555556 (* angle (* (+ b_m a_m) PI)))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	double tmp;
	if (pow(a_m, 2.0) <= 5e-239) {
		tmp = 2.0 * ((b_m - a_m) * (b_m * sin((((double) M_PI) * (0.005555555555555556 * angle)))));
	} else {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * ((double) M_PI)))));
	}
	return tmp;
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	double tmp;
	if (Math.pow(a_m, 2.0) <= 5e-239) {
		tmp = 2.0 * ((b_m - a_m) * (b_m * Math.sin((Math.PI * (0.005555555555555556 * angle)))));
	} else {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * Math.PI))));
	}
	return tmp;
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	tmp = 0
	if math.pow(a_m, 2.0) <= 5e-239:
		tmp = 2.0 * ((b_m - a_m) * (b_m * math.sin((math.pi * (0.005555555555555556 * angle)))))
	else:
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * math.pi))))
	return tmp

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	tmp = 0.0
	if ((a_m ^ 2.0) <= 5e-239)
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(b_m * sin(Float64(pi * Float64(0.005555555555555556 * angle))))));
	else
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(0.005555555555555556 * Float64(angle * Float64(Float64(b_m + a_m) * pi)))));
	end
	return tmp
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp_2 = code(a_m, b_m, angle)
	tmp = 0.0;
	if ((a_m ^ 2.0) <= 5e-239)
		tmp = 2.0 * ((b_m - a_m) * (b_m * sin((pi * (0.005555555555555556 * angle)))));
	else
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * pi))));
	end
	tmp_2 = tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := If[LessEqual[N[Power[a$95$m, 2.0], $MachinePrecision], 5e-239], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(b$95$m * N[Sin[N[(Pi * N[(0.005555555555555556 * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(0.005555555555555556 * N[(angle * N[(N[(b$95$m + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 3: 63.5% accurate, 2.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ \begin{array}{l} \mathbf{if}\;angle \leq 3.8 \cdot 10^{+16}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(0.005555555555555556 \cdot \left(angle \cdot \left(\left(b_m + a_m\right) \cdot \pi\right)\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right) \cdot \left(\left(b_m - a_m\right) \cdot \left(b_m + a_m\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (if (<= angle 3.8e+16)
   (*
    2.0
    (* (- b_m a_m) (* 0.005555555555555556 (* angle (* (+ b_m a_m) PI)))))
   (*
    2.0
    (*
     (sin (* 0.005555555555555556 (* PI angle)))
     (* (- b_m a_m) (+ b_m a_m))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	double tmp;
	if (angle <= 3.8e+16) {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * ((double) M_PI)))));
	} else {
		tmp = 2.0 * (sin((0.005555555555555556 * (((double) M_PI) * angle))) * ((b_m - a_m) * (b_m + a_m)));
	}
	return tmp;
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	double tmp;
	if (angle <= 3.8e+16) {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * Math.PI))));
	} else {
		tmp = 2.0 * (Math.sin((0.005555555555555556 * (Math.PI * angle))) * ((b_m - a_m) * (b_m + a_m)));
	}
	return tmp;
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	tmp = 0
	if angle <= 3.8e+16:
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * math.pi))))
	else:
		tmp = 2.0 * (math.sin((0.005555555555555556 * (math.pi * angle))) * ((b_m - a_m) * (b_m + a_m)))
	return tmp

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	tmp = 0.0
	if (angle <= 3.8e+16)
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(0.005555555555555556 * Float64(angle * Float64(Float64(b_m + a_m) * pi)))));
	else
		tmp = Float64(2.0 * Float64(sin(Float64(0.005555555555555556 * Float64(pi * angle))) * Float64(Float64(b_m - a_m) * Float64(b_m + a_m))));
	end
	return tmp
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp_2 = code(a_m, b_m, angle)
	tmp = 0.0;
	if (angle <= 3.8e+16)
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * pi))));
	else
		tmp = 2.0 * (sin((0.005555555555555556 * (pi * angle))) * ((b_m - a_m) * (b_m + a_m)));
	end
	tmp_2 = tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := If[LessEqual[angle, 3.8e+16], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(0.005555555555555556 * N[(angle * N[(N[(b$95$m + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(b$95$m + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 4: 64.1% accurate, 2.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ \begin{array}{l} \mathbf{if}\;b_m \leq 1.85 \cdot 10^{-135}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(a_m \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(b_m - a_m\right) \cdot \left(0.005555555555555556 \cdot \left(angle \cdot \left(\left(b_m + a_m\right) \cdot \pi\right)\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (if (<= b_m 1.85e-135)
   (* 2.0 (* (- b_m a_m) (* a_m (sin (* 0.005555555555555556 (* PI angle))))))
   (*
    2.0
    (* (- b_m a_m) (* 0.005555555555555556 (* angle (* (+ b_m a_m) PI)))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	double tmp;
	if (b_m <= 1.85e-135) {
		tmp = 2.0 * ((b_m - a_m) * (a_m * sin((0.005555555555555556 * (((double) M_PI) * angle)))));
	} else {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * ((double) M_PI)))));
	}
	return tmp;
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	double tmp;
	if (b_m <= 1.85e-135) {
		tmp = 2.0 * ((b_m - a_m) * (a_m * Math.sin((0.005555555555555556 * (Math.PI * angle)))));
	} else {
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * Math.PI))));
	}
	return tmp;
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	tmp = 0
	if b_m <= 1.85e-135:
		tmp = 2.0 * ((b_m - a_m) * (a_m * math.sin((0.005555555555555556 * (math.pi * angle)))))
	else:
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * math.pi))))
	return tmp

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	tmp = 0.0
	if (b_m <= 1.85e-135)
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m * sin(Float64(0.005555555555555556 * Float64(pi * angle))))));
	else
		tmp = Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(0.005555555555555556 * Float64(angle * Float64(Float64(b_m + a_m) * pi)))));
	end
	return tmp
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp_2 = code(a_m, b_m, angle)
	tmp = 0.0;
	if (b_m <= 1.85e-135)
		tmp = 2.0 * ((b_m - a_m) * (a_m * sin((0.005555555555555556 * (pi * angle)))));
	else
		tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * pi))));
	end
	tmp_2 = tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := If[LessEqual[b$95$m, 1.85e-135], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(0.005555555555555556 * N[(angle * N[(N[(b$95$m + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 5: 65.4% accurate, 2.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ 2 \cdot \left(\left(b_m - a_m\right) \cdot \left(\left(b_m + a_m\right) \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right) \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (*
  2.0
  (* (- b_m a_m) (* (+ b_m a_m) (sin (* 0.005555555555555556 (* PI angle)))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin((0.005555555555555556 * (((double) M_PI) * angle)))));
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * Math.sin((0.005555555555555556 * (Math.PI * angle)))));
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * math.sin((0.005555555555555556 * (math.pi * angle)))))

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	return Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(Float64(b_m + a_m) * sin(Float64(0.005555555555555556 * Float64(pi * angle))))))
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp = code(a_m, b_m, angle)
	tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin((0.005555555555555556 * (pi * angle)))));
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 6: 65.4% accurate, 2.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ 2 \cdot \left(\left(b_m - a_m\right) \cdot \left(\left(b_m + a_m\right) \cdot \sin \left(\pi \cdot \left(0.005555555555555556 \cdot angle\right)\right)\right)\right) \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (*
  2.0
  (* (- b_m a_m) (* (+ b_m a_m) (sin (* PI (* 0.005555555555555556 angle)))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin((((double) M_PI) * (0.005555555555555556 * angle)))));
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * Math.sin((Math.PI * (0.005555555555555556 * angle)))));
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	return 2.0 * ((b_m - a_m) * ((b_m + a_m) * math.sin((math.pi * (0.005555555555555556 * angle)))))

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	return Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(Float64(b_m + a_m) * sin(Float64(pi * Float64(0.005555555555555556 * angle))))))
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp = code(a_m, b_m, angle)
	tmp = 2.0 * ((b_m - a_m) * ((b_m + a_m) * sin((pi * (0.005555555555555556 * angle)))));
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(0.005555555555555556 * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 7: 61.6% accurate, 5.4× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ 2 \cdot \left(\left(b_m - a_m\right) \cdot \left(0.005555555555555556 \cdot \left(angle \cdot \left(\left(b_m + a_m\right) \cdot \pi\right)\right)\right)\right) \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (* 2.0 (* (- b_m a_m) (* 0.005555555555555556 (* angle (* (+ b_m a_m) PI))))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * ((double) M_PI)))));
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	return 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * Math.PI))));
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	return 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * math.pi))))

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	return Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(0.005555555555555556 * Float64(angle * Float64(Float64(b_m + a_m) * pi)))))
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp = code(a_m, b_m, angle)
	tmp = 2.0 * ((b_m - a_m) * (0.005555555555555556 * (angle * ((b_m + a_m) * pi))));
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(0.005555555555555556 * N[(angle * N[(N[(b$95$m + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 8: 53.6% accurate, 5.5× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ b_m = \left|b\right| \\ \left(angle \cdot 0.011111111111111112\right) \cdot \left(\pi \cdot \left(\left(b_m - a_m\right) \cdot \left(b_m + a_m\right)\right)\right) \end{array} \]

FPCore

a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
 :precision binary64
 (* (* angle 0.011111111111111112) (* PI (* (- b_m a_m) (+ b_m a_m)))))

C

a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
	return (angle * 0.011111111111111112) * (((double) M_PI) * ((b_m - a_m) * (b_m + a_m)));
}

Java

a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
	return (angle * 0.011111111111111112) * (Math.PI * ((b_m - a_m) * (b_m + a_m)));
}

Python

a_m = math.fabs(a)
b_m = math.fabs(b)
def code(a_m, b_m, angle):
	return (angle * 0.011111111111111112) * (math.pi * ((b_m - a_m) * (b_m + a_m)))

Julia

a_m = abs(a)
b_m = abs(b)
function code(a_m, b_m, angle)
	return Float64(Float64(angle * 0.011111111111111112) * Float64(pi * Float64(Float64(b_m - a_m) * Float64(b_m + a_m))))
end

MATLAB

a_m = abs(a);
b_m = abs(b);
function tmp = code(a_m, b_m, angle)
	tmp = (angle * 0.011111111111111112) * (pi * ((b_m - a_m) * (b_m + a_m)));
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := N[(N[(angle * 0.011111111111111112), $MachinePrecision] * N[(Pi * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(b$95$m + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2023364 
(FPCore (a b angle)
  :name "ab-angle->ABCF B"
  :precision binary64
  (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin (* PI (/ angle 180.0)))) (cos (* PI (/ angle 180.0)))))