ABCF->ab-angle angle

Percentage Accurate: 53.1% → 80.8%

Time: 21.9s

Alternatives: 21

Speedup: 2.4×

Specification

Math

\[\begin{array}{l} \\ 180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (*
  180.0
  (/
   (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))
   PI)))

C

double code(double A, double B, double C) {
	return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}

Java

public static double code(double A, double B, double C) {
	return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}

Python

def code(A, B, C):
	return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)

Julia

function code(A, B, C)
	return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi))
end

MATLAB

function tmp = code(A, B, C)
	tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi);
end

Wolfram

code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]

Initial Program: 53.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ 180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (*
  180.0
  (/
   (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))
   PI)))

C

double code(double A, double B, double C) {
	return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}

Java

public static double code(double A, double B, double C) {
	return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}

Python

def code(A, B, C):
	return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)

Julia

function code(A, B, C)
	return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi))
end

MATLAB

function tmp = code(A, B, C)
	tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi);
end

Wolfram

code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]

Alternative 1: 80.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -2.35 \cdot 10^{+92}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -2.35e+92)
   (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
   (/ (* 180.0 (atan (/ (- (- C A) (hypot (- A C) B)) B))) PI)))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -2.35e+92) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = (180.0 * atan((((C - A) - hypot((A - C), B)) / B))) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -2.35e+92) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = (180.0 * Math.atan((((C - A) - Math.hypot((A - C), B)) / B))) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -2.35e+92:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = (180.0 * math.atan((((C - A) - math.hypot((A - C), B)) / B))) / math.pi
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -2.35e+92)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B))) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -2.35e+92)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = (180.0 * atan((((C - A) - hypot((A - C), B)) / B))) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -2.35e+92], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]

Derivation

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

Alternative 2: 74.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\ t_1 := 180 \cdot \frac{\tan^{-1} \left(\frac{C + \left(B - A\right)}{B}\right)}{\pi}\\ \mathbf{if}\;A \leq -4.5 \cdot 10^{+91}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 1.9 \cdot 10^{-84}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;A \leq 6.2 \cdot 10^{+17}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;A \leq 6.6 \cdot 10^{+87}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;A \leq 1.9 \cdot 10^{+154}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(C - B\right) - A}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI)))
        (t_1 (* 180.0 (/ (atan (/ (+ C (- B A)) B)) PI))))
   (if (<= A -4.5e+91)
     (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
     (if (<= A 1.9e-84)
       t_0
       (if (<= A 6.2e+17)
         t_1
         (if (<= A 6.6e+87)
           t_0
           (if (<= A 1.9e+154)
             (/ (* 180.0 (atan (/ (- (- C B) A) B))) PI)
             t_1)))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
	double t_1 = 180.0 * (atan(((C + (B - A)) / B)) / ((double) M_PI));
	double tmp;
	if (A <= -4.5e+91) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else if (A <= 1.9e-84) {
		tmp = t_0;
	} else if (A <= 6.2e+17) {
		tmp = t_1;
	} else if (A <= 6.6e+87) {
		tmp = t_0;
	} else if (A <= 1.9e+154) {
		tmp = (180.0 * atan((((C - B) - A) / B))) / ((double) M_PI);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
	double t_1 = 180.0 * (Math.atan(((C + (B - A)) / B)) / Math.PI);
	double tmp;
	if (A <= -4.5e+91) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else if (A <= 1.9e-84) {
		tmp = t_0;
	} else if (A <= 6.2e+17) {
		tmp = t_1;
	} else if (A <= 6.6e+87) {
		tmp = t_0;
	} else if (A <= 1.9e+154) {
		tmp = (180.0 * Math.atan((((C - B) - A) / B))) / Math.PI;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi)
	t_1 = 180.0 * (math.atan(((C + (B - A)) / B)) / math.pi)
	tmp = 0
	if A <= -4.5e+91:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	elif A <= 1.9e-84:
		tmp = t_0
	elif A <= 6.2e+17:
		tmp = t_1
	elif A <= 6.6e+87:
		tmp = t_0
	elif A <= 1.9e+154:
		tmp = (180.0 * math.atan((((C - B) - A) / B))) / math.pi
	else:
		tmp = t_1
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi))
	t_1 = Float64(180.0 * Float64(atan(Float64(Float64(C + Float64(B - A)) / B)) / pi))
	tmp = 0.0
	if (A <= -4.5e+91)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	elseif (A <= 1.9e-84)
		tmp = t_0;
	elseif (A <= 6.2e+17)
		tmp = t_1;
	elseif (A <= 6.6e+87)
		tmp = t_0;
	elseif (A <= 1.9e+154)
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - B) - A) / B))) / pi);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi);
	t_1 = 180.0 * (atan(((C + (B - A)) / B)) / pi);
	tmp = 0.0;
	if (A <= -4.5e+91)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	elseif (A <= 1.9e-84)
		tmp = t_0;
	elseif (A <= 6.2e+17)
		tmp = t_1;
	elseif (A <= 6.6e+87)
		tmp = t_0;
	elseif (A <= 1.9e+154)
		tmp = (180.0 * atan((((C - B) - A) / B))) / pi;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[N[(N[(C + N[(B - A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -4.5e+91], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.9e-84], t$95$0, If[LessEqual[A, 6.2e+17], t$95$1, If[LessEqual[A, 6.6e+87], t$95$0, If[LessEqual[A, 1.9e+154], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - B), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], t$95$1]]]]]]]

Derivation

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

Alternative 3: 80.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -2 \cdot 10^{+93}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(B, A - C\right)\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -2e+93)
   (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
   (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -2e+93) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -2e+93) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -2e+93:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -2e+93)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(A - C)))) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -2e+93)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -2e+93], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 4: 77.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -1.4 \cdot 10^{+94}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 1.8 \cdot 10^{-133}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(-A\right) - \mathsf{hypot}\left(B, A\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -1.4e+94)
   (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
   (if (<= A 1.8e-133)
     (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
     (* 180.0 (/ (atan (/ (- (- A) (hypot B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -1.4e+94) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else if (A <= 1.8e-133) {
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(((-A - hypot(B, A)) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -1.4e+94) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else if (A <= 1.8e-133) {
		tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(((-A - Math.hypot(B, A)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -1.4e+94:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	elif A <= 1.8e-133:
		tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi)
	else:
		tmp = 180.0 * (math.atan(((-A - math.hypot(B, A)) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -1.4e+94)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	elseif (A <= 1.8e-133)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) - hypot(B, A)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -1.4e+94)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	elseif (A <= 1.8e-133)
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi);
	else
		tmp = 180.0 * (atan(((-A - hypot(B, A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -1.4e+94], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.8e-133], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[((-A) - N[Sqrt[B ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 5: 77.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -3.6 \cdot 10^{+90}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 1.35 \cdot 10^{-133}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(-A\right) - \mathsf{hypot}\left(A, B\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -3.6e+90)
   (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
   (if (<= A 1.35e-133)
     (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
     (/ (* 180.0 (atan (/ (- (- A) (hypot A B)) B))) PI))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -3.6e+90) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else if (A <= 1.35e-133) {
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
	} else {
		tmp = (180.0 * atan(((-A - hypot(A, B)) / B))) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -3.6e+90) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else if (A <= 1.35e-133) {
		tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
	} else {
		tmp = (180.0 * Math.atan(((-A - Math.hypot(A, B)) / B))) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -3.6e+90:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	elif A <= 1.35e-133:
		tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi)
	else:
		tmp = (180.0 * math.atan(((-A - math.hypot(A, B)) / B))) / math.pi
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -3.6e+90)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	elseif (A <= 1.35e-133)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi));
	else
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(-A) - hypot(A, B)) / B))) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -3.6e+90)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	elseif (A <= 1.35e-133)
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi);
	else
		tmp = (180.0 * atan(((-A - hypot(A, B)) / B))) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -3.6e+90], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.35e-133], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[((-A) - N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]

Derivation

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

Alternative 6: 52.0% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -7.8 \cdot 10^{-93}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 7.2 \cdot 10^{-211}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 2.35 \cdot 10^{-65} \lor \neg \left(C \leq 5.8 \cdot 10^{+91}\right):\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -7.8e-93)
   (* 180.0 (/ (atan (/ (- C B) B)) PI))
   (if (<= C 7.2e-211)
     (* 180.0 (/ (atan (/ (+ B C) B)) PI))
     (if (or (<= C 2.35e-65) (not (<= C 5.8e+91)))
       (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
       (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -7.8e-93) {
		tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
	} else if (C <= 7.2e-211) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if ((C <= 2.35e-65) || !(C <= 5.8e+91)) {
		tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -7.8e-93) {
		tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
	} else if (C <= 7.2e-211) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if ((C <= 2.35e-65) || !(C <= 5.8e+91)) {
		tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -7.8e-93:
		tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi)
	elif C <= 7.2e-211:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif (C <= 2.35e-65) or not (C <= 5.8e+91):
		tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi)
	else:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -7.8e-93)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi));
	elseif (C <= 7.2e-211)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif ((C <= 2.35e-65) || !(C <= 5.8e+91))
		tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -7.8e-93)
		tmp = 180.0 * (atan(((C - B) / B)) / pi);
	elseif (C <= 7.2e-211)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif ((C <= 2.35e-65) || ~((C <= 5.8e+91)))
		tmp = 180.0 * (atan((-0.5 * (B / C))) / pi);
	else
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -7.8e-93], N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 7.2e-211], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[C, 2.35e-65], N[Not[LessEqual[C, 5.8e+91]], $MachinePrecision]], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 7: 51.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -6.2 \cdot 10^{-90}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 6.8 \cdot 10^{-211}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 8 \cdot 10^{-70} \lor \neg \left(C \leq 2.5 \cdot 10^{+93}\right):\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -6.2e-90)
   (* 180.0 (/ (atan (/ (- C B) B)) PI))
   (if (<= C 6.8e-211)
     (* 180.0 (/ (atan (/ (+ B C) B)) PI))
     (if (or (<= C 8e-70) (not (<= C 2.5e+93)))
       (/ 180.0 (/ PI (atan (/ (* B -0.5) C))))
       (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -6.2e-90) {
		tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
	} else if (C <= 6.8e-211) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if ((C <= 8e-70) || !(C <= 2.5e+93)) {
		tmp = 180.0 / (((double) M_PI) / atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -6.2e-90) {
		tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
	} else if (C <= 6.8e-211) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if ((C <= 8e-70) || !(C <= 2.5e+93)) {
		tmp = 180.0 / (Math.PI / Math.atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -6.2e-90:
		tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi)
	elif C <= 6.8e-211:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif (C <= 8e-70) or not (C <= 2.5e+93):
		tmp = 180.0 / (math.pi / math.atan(((B * -0.5) / C)))
	else:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -6.2e-90)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi));
	elseif (C <= 6.8e-211)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif ((C <= 8e-70) || !(C <= 2.5e+93))
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(B * -0.5) / C))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -6.2e-90)
		tmp = 180.0 * (atan(((C - B) / B)) / pi);
	elseif (C <= 6.8e-211)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif ((C <= 8e-70) || ~((C <= 2.5e+93)))
		tmp = 180.0 / (pi / atan(((B * -0.5) / C)));
	else
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -6.2e-90], N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6.8e-211], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[C, 8e-70], N[Not[LessEqual[C, 2.5e+93]], $MachinePrecision]], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 8: 50.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -1.4 \cdot 10^{-141}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 5.6 \cdot 10^{-301}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \mathbf{elif}\;B \leq 2 \cdot 10^{-200}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 1.9 \cdot 10^{+23}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -1.4e-141)
   (* 180.0 (/ (atan (/ (+ B C) B)) PI))
   (if (<= B 5.6e-301)
     (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
     (if (<= B 2e-200)
       (* 180.0 (/ (atan (/ (- A) B)) PI))
       (if (<= B 1.9e+23)
         (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
         (* 180.0 (/ (atan -1.0) PI)))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -1.4e-141) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if (B <= 5.6e-301) {
		tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
	} else if (B <= 2e-200) {
		tmp = 180.0 * (atan((-A / B)) / ((double) M_PI));
	} else if (B <= 1.9e+23) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (B <= -1.4e-141) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if (B <= 5.6e-301) {
		tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
	} else if (B <= 2e-200) {
		tmp = 180.0 * (Math.atan((-A / B)) / Math.PI);
	} else if (B <= 1.9e+23) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -1.4e-141:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif B <= 5.6e-301:
		tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi)
	elif B <= 2e-200:
		tmp = 180.0 * (math.atan((-A / B)) / math.pi)
	elif B <= 1.9e+23:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -1.4e-141)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif (B <= 5.6e-301)
		tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi));
	elseif (B <= 2e-200)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(-A) / B)) / pi));
	elseif (B <= 1.9e+23)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -1.4e-141)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif (B <= 5.6e-301)
		tmp = 180.0 * (atan((-0.5 * (B / C))) / pi);
	elseif (B <= 2e-200)
		tmp = 180.0 * (atan((-A / B)) / pi);
	elseif (B <= 1.9e+23)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -1.4e-141], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5.6e-301], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2e-200], N[(180.0 * N[(N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.9e+23], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 9: 51.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)\\ \mathbf{if}\;C \leq -1.75 \cdot 10^{-95}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 2.2 \cdot 10^{-213}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 8 \cdot 10^{-64}:\\ \;\;\;\;\frac{180}{\frac{\pi}{t_0}}\\ \mathbf{elif}\;C \leq 4.6 \cdot 10^{+91}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot t_0}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (atan (/ (* B -0.5) C))))
   (if (<= C -1.75e-95)
     (* 180.0 (/ (atan (/ (- C B) B)) PI))
     (if (<= C 2.2e-213)
       (* 180.0 (/ (atan (/ (+ B C) B)) PI))
       (if (<= C 8e-64)
         (/ 180.0 (/ PI t_0))
         (if (<= C 4.6e+91)
           (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
           (/ (* 180.0 t_0) PI)))))))

C

double code(double A, double B, double C) {
	double t_0 = atan(((B * -0.5) / C));
	double tmp;
	if (C <= -1.75e-95) {
		tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
	} else if (C <= 2.2e-213) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if (C <= 8e-64) {
		tmp = 180.0 / (((double) M_PI) / t_0);
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = (180.0 * t_0) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = Math.atan(((B * -0.5) / C));
	double tmp;
	if (C <= -1.75e-95) {
		tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
	} else if (C <= 2.2e-213) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if (C <= 8e-64) {
		tmp = 180.0 / (Math.PI / t_0);
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = (180.0 * t_0) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = math.atan(((B * -0.5) / C))
	tmp = 0
	if C <= -1.75e-95:
		tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi)
	elif C <= 2.2e-213:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif C <= 8e-64:
		tmp = 180.0 / (math.pi / t_0)
	elif C <= 4.6e+91:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = (180.0 * t_0) / math.pi
	return tmp

Julia

function code(A, B, C)
	t_0 = atan(Float64(Float64(B * -0.5) / C))
	tmp = 0.0
	if (C <= -1.75e-95)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi));
	elseif (C <= 2.2e-213)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif (C <= 8e-64)
		tmp = Float64(180.0 / Float64(pi / t_0));
	elseif (C <= 4.6e+91)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(Float64(180.0 * t_0) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = atan(((B * -0.5) / C));
	tmp = 0.0;
	if (C <= -1.75e-95)
		tmp = 180.0 * (atan(((C - B) / B)) / pi);
	elseif (C <= 2.2e-213)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif (C <= 8e-64)
		tmp = 180.0 / (pi / t_0);
	elseif (C <= 4.6e+91)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = (180.0 * t_0) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[C, -1.75e-95], N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.2e-213], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 8e-64], N[(180.0 / N[(Pi / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.6e+91], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * t$95$0), $MachinePrecision] / Pi), $MachinePrecision]]]]]]

Derivation

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

Alternative 10: 52.0% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)\\ \mathbf{if}\;C \leq -3.3 \cdot 10^{-93}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 8.5 \cdot 10^{-212}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 7 \cdot 10^{-63}:\\ \;\;\;\;\frac{180}{\frac{\pi}{t_0}}\\ \mathbf{elif}\;C \leq 4.6 \cdot 10^{+91}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot t_0}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (atan (/ (* B -0.5) C))))
   (if (<= C -3.3e-93)
     (/ (* 180.0 (atan (/ (- C B) B))) PI)
     (if (<= C 8.5e-212)
       (* 180.0 (/ (atan (/ (+ B C) B)) PI))
       (if (<= C 7e-63)
         (/ 180.0 (/ PI t_0))
         (if (<= C 4.6e+91)
           (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
           (/ (* 180.0 t_0) PI)))))))

C

double code(double A, double B, double C) {
	double t_0 = atan(((B * -0.5) / C));
	double tmp;
	if (C <= -3.3e-93) {
		tmp = (180.0 * atan(((C - B) / B))) / ((double) M_PI);
	} else if (C <= 8.5e-212) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if (C <= 7e-63) {
		tmp = 180.0 / (((double) M_PI) / t_0);
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = (180.0 * t_0) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = Math.atan(((B * -0.5) / C));
	double tmp;
	if (C <= -3.3e-93) {
		tmp = (180.0 * Math.atan(((C - B) / B))) / Math.PI;
	} else if (C <= 8.5e-212) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if (C <= 7e-63) {
		tmp = 180.0 / (Math.PI / t_0);
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = (180.0 * t_0) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = math.atan(((B * -0.5) / C))
	tmp = 0
	if C <= -3.3e-93:
		tmp = (180.0 * math.atan(((C - B) / B))) / math.pi
	elif C <= 8.5e-212:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif C <= 7e-63:
		tmp = 180.0 / (math.pi / t_0)
	elif C <= 4.6e+91:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = (180.0 * t_0) / math.pi
	return tmp

Julia

function code(A, B, C)
	t_0 = atan(Float64(Float64(B * -0.5) / C))
	tmp = 0.0
	if (C <= -3.3e-93)
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - B) / B))) / pi);
	elseif (C <= 8.5e-212)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif (C <= 7e-63)
		tmp = Float64(180.0 / Float64(pi / t_0));
	elseif (C <= 4.6e+91)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(Float64(180.0 * t_0) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = atan(((B * -0.5) / C));
	tmp = 0.0;
	if (C <= -3.3e-93)
		tmp = (180.0 * atan(((C - B) / B))) / pi;
	elseif (C <= 8.5e-212)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif (C <= 7e-63)
		tmp = 180.0 / (pi / t_0);
	elseif (C <= 4.6e+91)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = (180.0 * t_0) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[C, -3.3e-93], N[(N[(180.0 * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 8.5e-212], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 7e-63], N[(180.0 / N[(Pi / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.6e+91], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * t$95$0), $MachinePrecision] / Pi), $MachinePrecision]]]]]]

Derivation

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

Alternative 11: 57.4% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -3.05 \cdot 10^{-92}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq -5.2 \cdot 10^{-208}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 9.2 \cdot 10^{-63}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(-B\right) - A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 4.6 \cdot 10^{+91}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -3.05e-92)
   (/ (* 180.0 (atan (/ (- C B) B))) PI)
   (if (<= C -5.2e-208)
     (* 180.0 (/ (atan (/ (+ B C) B)) PI))
     (if (<= C 9.2e-63)
       (/ (* 180.0 (atan (/ (- (- B) A) B))) PI)
       (if (<= C 4.6e+91)
         (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
         (/ (* 180.0 (atan (/ (* B -0.5) C))) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -3.05e-92) {
		tmp = (180.0 * atan(((C - B) / B))) / ((double) M_PI);
	} else if (C <= -5.2e-208) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if (C <= 9.2e-63) {
		tmp = (180.0 * atan(((-B - A) / B))) / ((double) M_PI);
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else {
		tmp = (180.0 * atan(((B * -0.5) / C))) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -3.05e-92) {
		tmp = (180.0 * Math.atan(((C - B) / B))) / Math.PI;
	} else if (C <= -5.2e-208) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if (C <= 9.2e-63) {
		tmp = (180.0 * Math.atan(((-B - A) / B))) / Math.PI;
	} else if (C <= 4.6e+91) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else {
		tmp = (180.0 * Math.atan(((B * -0.5) / C))) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -3.05e-92:
		tmp = (180.0 * math.atan(((C - B) / B))) / math.pi
	elif C <= -5.2e-208:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif C <= 9.2e-63:
		tmp = (180.0 * math.atan(((-B - A) / B))) / math.pi
	elif C <= 4.6e+91:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	else:
		tmp = (180.0 * math.atan(((B * -0.5) / C))) / math.pi
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -3.05e-92)
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - B) / B))) / pi);
	elseif (C <= -5.2e-208)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif (C <= 9.2e-63)
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(-B) - A) / B))) / pi);
	elseif (C <= 4.6e+91)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	else
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * -0.5) / C))) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -3.05e-92)
		tmp = (180.0 * atan(((C - B) / B))) / pi;
	elseif (C <= -5.2e-208)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif (C <= 9.2e-63)
		tmp = (180.0 * atan(((-B - A) / B))) / pi;
	elseif (C <= 4.6e+91)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	else
		tmp = (180.0 * atan(((B * -0.5) / C))) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -3.05e-92], N[(N[(180.0 * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, -5.2e-208], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 9.2e-63], N[(N[(180.0 * N[ArcTan[N[(N[((-B) - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 4.6e+91], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]]]

Derivation

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

Alternative 12: 44.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\ t_1 := 180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{if}\;B \leq -7.2 \cdot 10^{-40}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;B \leq -2.75 \cdot 10^{-86}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;B \leq -8.2 \cdot 10^{-187}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;B \leq 4.5 \cdot 10^{-178}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ 0.0 B)) PI)))
        (t_1 (* 180.0 (/ (atan 1.0) PI))))
   (if (<= B -7.2e-40)
     t_1
     (if (<= B -2.75e-86)
       t_0
       (if (<= B -8.2e-187)
         t_1
         (if (<= B 4.5e-178) t_0 (* 180.0 (/ (atan -1.0) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
	double t_1 = 180.0 * (atan(1.0) / ((double) M_PI));
	double tmp;
	if (B <= -7.2e-40) {
		tmp = t_1;
	} else if (B <= -2.75e-86) {
		tmp = t_0;
	} else if (B <= -8.2e-187) {
		tmp = t_1;
	} else if (B <= 4.5e-178) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
	double t_1 = 180.0 * (Math.atan(1.0) / Math.PI);
	double tmp;
	if (B <= -7.2e-40) {
		tmp = t_1;
	} else if (B <= -2.75e-86) {
		tmp = t_0;
	} else if (B <= -8.2e-187) {
		tmp = t_1;
	} else if (B <= 4.5e-178) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan((0.0 / B)) / math.pi)
	t_1 = 180.0 * (math.atan(1.0) / math.pi)
	tmp = 0
	if B <= -7.2e-40:
		tmp = t_1
	elif B <= -2.75e-86:
		tmp = t_0
	elif B <= -8.2e-187:
		tmp = t_1
	elif B <= 4.5e-178:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi))
	t_1 = Float64(180.0 * Float64(atan(1.0) / pi))
	tmp = 0.0
	if (B <= -7.2e-40)
		tmp = t_1;
	elseif (B <= -2.75e-86)
		tmp = t_0;
	elseif (B <= -8.2e-187)
		tmp = t_1;
	elseif (B <= 4.5e-178)
		tmp = t_0;
	else
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan((0.0 / B)) / pi);
	t_1 = 180.0 * (atan(1.0) / pi);
	tmp = 0.0;
	if (B <= -7.2e-40)
		tmp = t_1;
	elseif (B <= -2.75e-86)
		tmp = t_0;
	elseif (B <= -8.2e-187)
		tmp = t_1;
	elseif (B <= 4.5e-178)
		tmp = t_0;
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -7.2e-40], t$95$1, If[LessEqual[B, -2.75e-86], t$95$0, If[LessEqual[B, -8.2e-187], t$95$1, If[LessEqual[B, 4.5e-178], t$95$0, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

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

Alternative 13: 46.6% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\ \mathbf{if}\;B \leq -1720:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq -6 \cdot 10^{-140}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;B \leq 6.3 \cdot 10^{-301}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 1.65 \cdot 10^{+20}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ C B)) PI))))
   (if (<= B -1720.0)
     (* 180.0 (/ (atan 1.0) PI))
     (if (<= B -6e-140)
       t_0
       (if (<= B 6.3e-301)
         (* 180.0 (/ (atan (/ 0.0 B)) PI))
         (if (<= B 1.65e+20) t_0 (* 180.0 (/ (atan -1.0) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan((C / B)) / ((double) M_PI));
	double tmp;
	if (B <= -1720.0) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= -6e-140) {
		tmp = t_0;
	} else if (B <= 6.3e-301) {
		tmp = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
	} else if (B <= 1.65e+20) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan((C / B)) / Math.PI);
	double tmp;
	if (B <= -1720.0) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= -6e-140) {
		tmp = t_0;
	} else if (B <= 6.3e-301) {
		tmp = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
	} else if (B <= 1.65e+20) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan((C / B)) / math.pi)
	tmp = 0
	if B <= -1720.0:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= -6e-140:
		tmp = t_0
	elif B <= 6.3e-301:
		tmp = 180.0 * (math.atan((0.0 / B)) / math.pi)
	elif B <= 1.65e+20:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(C / B)) / pi))
	tmp = 0.0
	if (B <= -1720.0)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= -6e-140)
		tmp = t_0;
	elseif (B <= 6.3e-301)
		tmp = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi));
	elseif (B <= 1.65e+20)
		tmp = t_0;
	else
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan((C / B)) / pi);
	tmp = 0.0;
	if (B <= -1720.0)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= -6e-140)
		tmp = t_0;
	elseif (B <= 6.3e-301)
		tmp = 180.0 * (atan((0.0 / B)) / pi);
	elseif (B <= 1.65e+20)
		tmp = t_0;
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -1720.0], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -6e-140], t$95$0, If[LessEqual[B, 6.3e-301], N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.65e+20], t$95$0, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 14: 60.5% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -3 \cdot 10^{-140}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq -1.65 \cdot 10^{-294}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + B\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -3e-140)
   (* 180.0 (/ (atan (/ (+ B C) B)) PI))
   (if (<= B -1.65e-294)
     (/ 180.0 (/ PI (atan (/ (* B -0.5) C))))
     (* 180.0 (/ (atan (/ (- C (+ A B)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -3e-140) {
		tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	} else if (B <= -1.65e-294) {
		tmp = 180.0 / (((double) M_PI) / atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (atan(((C - (A + B)) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (B <= -3e-140) {
		tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	} else if (B <= -1.65e-294) {
		tmp = 180.0 / (Math.PI / Math.atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (Math.atan(((C - (A + B)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -3e-140:
		tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	elif B <= -1.65e-294:
		tmp = 180.0 / (math.pi / math.atan(((B * -0.5) / C)))
	else:
		tmp = 180.0 * (math.atan(((C - (A + B)) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -3e-140)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi));
	elseif (B <= -1.65e-294)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(B * -0.5) / C))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + B)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -3e-140)
		tmp = 180.0 * (atan(((B + C) / B)) / pi);
	elseif (B <= -1.65e-294)
		tmp = 180.0 / (pi / atan(((B * -0.5) / C)));
	else
		tmp = 180.0 * (atan(((C - (A + B)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -3e-140], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.65e-294], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 15: 64.2% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.4 \cdot 10^{-143}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C + \left(B - A\right)}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq -1.5 \cdot 10^{-294}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + B\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -2.4e-143)
   (* 180.0 (/ (atan (/ (+ C (- B A)) B)) PI))
   (if (<= B -1.5e-294)
     (/ 180.0 (/ PI (atan (/ (* B -0.5) C))))
     (* 180.0 (/ (atan (/ (- C (+ A B)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.4e-143) {
		tmp = 180.0 * (atan(((C + (B - A)) / B)) / ((double) M_PI));
	} else if (B <= -1.5e-294) {
		tmp = 180.0 / (((double) M_PI) / atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (atan(((C - (A + B)) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.4e-143) {
		tmp = 180.0 * (Math.atan(((C + (B - A)) / B)) / Math.PI);
	} else if (B <= -1.5e-294) {
		tmp = 180.0 / (Math.PI / Math.atan(((B * -0.5) / C)));
	} else {
		tmp = 180.0 * (Math.atan(((C - (A + B)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -2.4e-143:
		tmp = 180.0 * (math.atan(((C + (B - A)) / B)) / math.pi)
	elif B <= -1.5e-294:
		tmp = 180.0 / (math.pi / math.atan(((B * -0.5) / C)))
	else:
		tmp = 180.0 * (math.atan(((C - (A + B)) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -2.4e-143)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C + Float64(B - A)) / B)) / pi));
	elseif (B <= -1.5e-294)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(B * -0.5) / C))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + B)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -2.4e-143)
		tmp = 180.0 * (atan(((C + (B - A)) / B)) / pi);
	elseif (B <= -1.5e-294)
		tmp = 180.0 / (pi / atan(((B * -0.5) / C)));
	else
		tmp = 180.0 * (atan(((C - (A + B)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2.4e-143], N[(180.0 * N[(N[ArcTan[N[(N[(C + N[(B - A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.5e-294], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 16: 64.2% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.6 \cdot 10^{-143}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C + \left(B - A\right)}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq -1.4 \cdot 10^{-294}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)}}\\ \mathbf{else}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(C - B\right) - A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -2.6e-143)
   (* 180.0 (/ (atan (/ (+ C (- B A)) B)) PI))
   (if (<= B -1.4e-294)
     (/ 180.0 (/ PI (atan (/ (* B -0.5) C))))
     (/ (* 180.0 (atan (/ (- (- C B) A) B))) PI))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.6e-143) {
		tmp = 180.0 * (atan(((C + (B - A)) / B)) / ((double) M_PI));
	} else if (B <= -1.4e-294) {
		tmp = 180.0 / (((double) M_PI) / atan(((B * -0.5) / C)));
	} else {
		tmp = (180.0 * atan((((C - B) - A) / B))) / ((double) M_PI);
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.6e-143) {
		tmp = 180.0 * (Math.atan(((C + (B - A)) / B)) / Math.PI);
	} else if (B <= -1.4e-294) {
		tmp = 180.0 / (Math.PI / Math.atan(((B * -0.5) / C)));
	} else {
		tmp = (180.0 * Math.atan((((C - B) - A) / B))) / Math.PI;
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -2.6e-143:
		tmp = 180.0 * (math.atan(((C + (B - A)) / B)) / math.pi)
	elif B <= -1.4e-294:
		tmp = 180.0 / (math.pi / math.atan(((B * -0.5) / C)))
	else:
		tmp = (180.0 * math.atan((((C - B) - A) / B))) / math.pi
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -2.6e-143)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C + Float64(B - A)) / B)) / pi));
	elseif (B <= -1.4e-294)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(B * -0.5) / C))));
	else
		tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - B) - A) / B))) / pi);
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -2.6e-143)
		tmp = 180.0 * (atan(((C + (B - A)) / B)) / pi);
	elseif (B <= -1.4e-294)
		tmp = 180.0 / (pi / atan(((B * -0.5) / C)));
	else
		tmp = (180.0 * atan((((C - B) - A) / B))) / pi;
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2.6e-143], N[(180.0 * N[(N[ArcTan[N[(N[(C + N[(B - A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.4e-294], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - B), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]

Derivation

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

Alternative 17: 48.4% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -2.25 \cdot 10^{-45}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 7.2 \cdot 10^{-212}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -2.25e-45)
   (* 180.0 (/ (atan (/ C B)) PI))
   (if (<= C 7.2e-212)
     (* 180.0 (/ (atan 1.0) PI))
     (* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.25e-45) {
		tmp = 180.0 * (atan((C / B)) / ((double) M_PI));
	} else if (C <= 7.2e-212) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.25e-45) {
		tmp = 180.0 * (Math.atan((C / B)) / Math.PI);
	} else if (C <= 7.2e-212) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -2.25e-45:
		tmp = 180.0 * (math.atan((C / B)) / math.pi)
	elif C <= 7.2e-212:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	else:
		tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -2.25e-45)
		tmp = Float64(180.0 * Float64(atan(Float64(C / B)) / pi));
	elseif (C <= 7.2e-212)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -2.25e-45)
		tmp = 180.0 * (atan((C / B)) / pi);
	elseif (C <= 7.2e-212)
		tmp = 180.0 * (atan(1.0) / pi);
	else
		tmp = 180.0 * (atan((-0.5 * (B / C))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -2.25e-45], N[(180.0 * N[(N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 7.2e-212], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 18: 48.6% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -5.2 \cdot 10^{-45}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(2 \cdot \frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 4.6 \cdot 10^{-212}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -5.2e-45)
   (* 180.0 (/ (atan (* 2.0 (/ C B))) PI))
   (if (<= C 4.6e-212)
     (* 180.0 (/ (atan 1.0) PI))
     (* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -5.2e-45) {
		tmp = 180.0 * (atan((2.0 * (C / B))) / ((double) M_PI));
	} else if (C <= 4.6e-212) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -5.2e-45) {
		tmp = 180.0 * (Math.atan((2.0 * (C / B))) / Math.PI);
	} else if (C <= 4.6e-212) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -5.2e-45:
		tmp = 180.0 * (math.atan((2.0 * (C / B))) / math.pi)
	elif C <= 4.6e-212:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	else:
		tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -5.2e-45)
		tmp = Float64(180.0 * Float64(atan(Float64(2.0 * Float64(C / B))) / pi));
	elseif (C <= 4.6e-212)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -5.2e-45)
		tmp = 180.0 * (atan((2.0 * (C / B))) / pi);
	elseif (C <= 4.6e-212)
		tmp = 180.0 * (atan(1.0) / pi);
	else
		tmp = 180.0 * (atan((-0.5 * (B / C))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -5.2e-45], N[(180.0 * N[(N[ArcTan[N[(2.0 * N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.6e-212], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 19: 48.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -5.5 \cdot 10^{-271}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 3.1 \cdot 10^{-33}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -5.5e-271)
   (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
   (if (<= A 3.1e-33)
     (* 180.0 (/ (atan 1.0) PI))
     (* 180.0 (/ (atan (* -2.0 (/ A B))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e-271) {
		tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
	} else if (A <= 3.1e-33) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((-2.0 * (A / B))) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e-271) {
		tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
	} else if (A <= 3.1e-33) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -5.5e-271:
		tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi)
	elif A <= 3.1e-33:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	else:
		tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -5.5e-271)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi));
	elseif (A <= 3.1e-33)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -5.5e-271)
		tmp = 180.0 * (atan(((0.5 * B) / A)) / pi);
	elseif (A <= 3.1e-33)
		tmp = 180.0 * (atan(1.0) / pi);
	else
		tmp = 180.0 * (atan((-2.0 * (A / B))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -5.5e-271], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 3.1e-33], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 20: 40.1% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2 \cdot 10^{-310}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -2e-310) (* 180.0 (/ (atan 1.0) PI)) (* 180.0 (/ (atan -1.0) PI))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2e-310) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (B <= -2e-310) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -2e-310:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	else:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -2e-310)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -2e-310)
		tmp = 180.0 * (atan(1.0) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2e-310], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 21: 21.2% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ 180 \cdot \frac{\tan^{-1} -1}{\pi} \end{array} \]

FPCore

(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan -1.0) PI)))

C

double code(double A, double B, double C) {
	return 180.0 * (atan(-1.0) / ((double) M_PI));
}

Java

public static double code(double A, double B, double C) {
	return 180.0 * (Math.atan(-1.0) / Math.PI);
}

Python

def code(A, B, C):
	return 180.0 * (math.atan(-1.0) / math.pi)

Julia

function code(A, B, C)
	return Float64(180.0 * Float64(atan(-1.0) / pi))
end

MATLAB

function tmp = code(A, B, C)
	tmp = 180.0 * (atan(-1.0) / pi);
end

Wolfram

code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2023336 
(FPCore (A B C)
  :name "ABCF->ab-angle angle"
  :precision binary64
  (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))) PI)))