ABCF->ab-angle angle

Percentage Accurate: 53.8% → 82.4%

Time: 27.0s

Alternatives: 14

Speedup: 3.5×

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.8% 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: 82.4% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0
         (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
   (if (or (<= t_0 -2e-13) (not (<= t_0 0.0)))
     (/ 180.0 (/ PI (atan (/ (- (- C A) (hypot (- A C) B)) B))))
     (* 180.0 (/ (atan (+ (/ (* A 0.0) B) (* -0.5 (/ B C)))) PI)))))

C

double code(double A, double B, double C) {
	double t_0 = (1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0))));
	double tmp;
	if ((t_0 <= -2e-13) || !(t_0 <= 0.0)) {
		tmp = 180.0 / (((double) M_PI) / atan((((C - A) - hypot((A - C), B)) / B)));
	} else {
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = (1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0))));
	double tmp;
	if ((t_0 <= -2e-13) || !(t_0 <= 0.0)) {
		tmp = 180.0 / (Math.PI / Math.atan((((C - A) - Math.hypot((A - C), B)) / B)));
	} else {
		tmp = 180.0 * (Math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = (1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0))))
	tmp = 0
	if (t_0 <= -2e-13) or not (t_0 <= 0.0):
		tmp = 180.0 / (math.pi / math.atan((((C - A) - math.hypot((A - C), B)) / B)))
	else:
		tmp = 180.0 * (math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))
	tmp = 0.0
	if ((t_0 <= -2e-13) || !(t_0 <= 0.0))
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(A * 0.0) / B) + Float64(-0.5 * Float64(B / C)))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = (1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0))));
	tmp = 0.0;
	if ((t_0 <= -2e-13) || ~((t_0 <= 0.0)))
		tmp = 180.0 / (pi / atan((((C - A) - hypot((A - C), B)) / B)));
	else
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = 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]}, If[Or[LessEqual[t$95$0, -2e-13], N[Not[LessEqual[t$95$0, 0.0]], $MachinePrecision]], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(A * 0.0), $MachinePrecision] / B), $MachinePrecision] + N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 2: 77.9% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -5.5 \cdot 10^{+180}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 1.75 \cdot 10^{-44} \lor \neg \left(A \leq 2.05 \cdot 10^{-5}\right):\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(B, A - C\right)\right)}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A \cdot 0}{B} + -0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -5.5e+180)
   (/ (* 180.0 (atan (* 0.5 (/ B A)))) PI)
   (if (or (<= A 1.75e-44) (not (<= A 2.05e-5)))
     (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))
     (* 180.0 (/ (atan (+ (/ (* A 0.0) B) (* -0.5 (/ B C)))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e+180) {
		tmp = (180.0 * atan((0.5 * (B / A)))) / ((double) M_PI);
	} else if ((A <= 1.75e-44) || !(A <= 2.05e-5)) {
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e+180) {
		tmp = (180.0 * Math.atan((0.5 * (B / A)))) / Math.PI;
	} else if ((A <= 1.75e-44) || !(A <= 2.05e-5)) {
		tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -5.5e+180:
		tmp = (180.0 * math.atan((0.5 * (B / A)))) / math.pi
	elif (A <= 1.75e-44) or not (A <= 2.05e-5):
		tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi)
	else:
		tmp = 180.0 * (math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -5.5e+180)
		tmp = Float64(Float64(180.0 * atan(Float64(0.5 * Float64(B / A)))) / pi);
	elseif ((A <= 1.75e-44) || !(A <= 2.05e-5))
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(A - C)))) / B)) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(A * 0.0) / B) + Float64(-0.5 * Float64(B / C)))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -5.5e+180)
		tmp = (180.0 * atan((0.5 * (B / A)))) / pi;
	elseif ((A <= 1.75e-44) || ~((A <= 2.05e-5)))
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi);
	else
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -5.5e+180], N[(N[(180.0 * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[Or[LessEqual[A, 1.75e-44], N[Not[LessEqual[A, 2.05e-5]], $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], N[(180.0 * N[(N[ArcTan[N[(N[(N[(A * 0.0), $MachinePrecision] / B), $MachinePrecision] + N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 3: 77.9% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -5.5e+180)
   (/ (* 180.0 (atan (* 0.5 (/ B A)))) PI)
   (if (<= A 1.75e-44)
     (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))
     (if (<= A 2.05e-5)
       (* 180.0 (/ (atan (+ (/ (* A 0.0) B) (* -0.5 (/ B C)))) PI))
       (* (/ 180.0 PI) (atan (/ (- C (+ A (hypot (- A C) B))) B)))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e+180) {
		tmp = (180.0 * atan((0.5 * (B / A)))) / ((double) M_PI);
	} else if (A <= 1.75e-44) {
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
	} else if (A <= 2.05e-5) {
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / ((double) M_PI));
	} else {
		tmp = (180.0 / ((double) M_PI)) * atan(((C - (A + hypot((A - C), B))) / B));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (A <= -5.5e+180) {
		tmp = (180.0 * Math.atan((0.5 * (B / A)))) / Math.PI;
	} else if (A <= 1.75e-44) {
		tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
	} else if (A <= 2.05e-5) {
		tmp = 180.0 * (Math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / Math.PI);
	} else {
		tmp = (180.0 / Math.PI) * Math.atan(((C - (A + Math.hypot((A - C), B))) / B));
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -5.5e+180:
		tmp = (180.0 * math.atan((0.5 * (B / A)))) / math.pi
	elif A <= 1.75e-44:
		tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi)
	elif A <= 2.05e-5:
		tmp = 180.0 * (math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / math.pi)
	else:
		tmp = (180.0 / math.pi) * math.atan(((C - (A + math.hypot((A - C), B))) / B))
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -5.5e+180)
		tmp = Float64(Float64(180.0 * atan(Float64(0.5 * Float64(B / A)))) / pi);
	elseif (A <= 1.75e-44)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(A - C)))) / B)) / pi));
	elseif (A <= 2.05e-5)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(A * 0.0) / B) + Float64(-0.5 * Float64(B / C)))) / pi));
	else
		tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(A + hypot(Float64(A - C), B))) / B)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -5.5e+180)
		tmp = (180.0 * atan((0.5 * (B / A)))) / pi;
	elseif (A <= 1.75e-44)
		tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi);
	elseif (A <= 2.05e-5)
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / pi);
	else
		tmp = (180.0 / pi) * atan(((C - (A + hypot((A - C), B))) / B));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -5.5e+180], N[(N[(180.0 * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.75e-44], 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], If[LessEqual[A, 2.05e-5], N[(180.0 * N[(N[ArcTan[N[(N[(N[(A * 0.0), $MachinePrecision] / B), $MachinePrecision] + N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(A + N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 4: 64.9% accurate, 3.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.3 \cdot 10^{-134}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(B + C\right) - A}{B}\right)}}\\ \mathbf{elif}\;B \leq -1.1 \cdot 10^{-155}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A \cdot 0}{B} + -0.5 \cdot \frac{B}{C}\right)}{\pi}\\ \mathbf{elif}\;B \leq -5.2 \cdot 10^{-193}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq -8.2 \cdot 10^{-265}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0}{B}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -2.3e-134)
   (/ 180.0 (/ PI (atan (/ (- (+ B C) A) B))))
   (if (<= B -1.1e-155)
     (* 180.0 (/ (atan (+ (/ (* A 0.0) B) (* -0.5 (/ B C)))) PI))
     (if (<= B -5.2e-193)
       (* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI))
       (if (<= B -8.2e-265)
         (/ 180.0 (/ PI (atan (/ 0.0 B))))
         (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.3e-134) {
		tmp = 180.0 / (((double) M_PI) / atan((((B + C) - A) / B)));
	} else if (B <= -1.1e-155) {
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / ((double) M_PI));
	} else if (B <= -5.2e-193) {
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
	} else if (B <= -8.2e-265) {
		tmp = 180.0 / (((double) M_PI) / atan((0.0 / B)));
	} 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.3e-134) {
		tmp = 180.0 / (Math.PI / Math.atan((((B + C) - A) / B)));
	} else if (B <= -1.1e-155) {
		tmp = 180.0 * (Math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / Math.PI);
	} else if (B <= -5.2e-193) {
		tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
	} else if (B <= -8.2e-265) {
		tmp = 180.0 / (Math.PI / Math.atan((0.0 / B)));
	} 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.3e-134:
		tmp = 180.0 / (math.pi / math.atan((((B + C) - A) / B)))
	elif B <= -1.1e-155:
		tmp = 180.0 * (math.atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / math.pi)
	elif B <= -5.2e-193:
		tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi)
	elif B <= -8.2e-265:
		tmp = 180.0 / (math.pi / math.atan((0.0 / B)))
	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.3e-134)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(B + C) - A) / B))));
	elseif (B <= -1.1e-155)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(A * 0.0) / B) + Float64(-0.5 * Float64(B / C)))) / pi));
	elseif (B <= -5.2e-193)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi));
	elseif (B <= -8.2e-265)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(0.0 / B))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -2.3e-134)
		tmp = 180.0 / (pi / atan((((B + C) - A) / B)));
	elseif (B <= -1.1e-155)
		tmp = 180.0 * (atan((((A * 0.0) / B) + (-0.5 * (B / C)))) / pi);
	elseif (B <= -5.2e-193)
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi);
	elseif (B <= -8.2e-265)
		tmp = 180.0 / (pi / atan((0.0 / B)));
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2.3e-134], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(B + C), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.1e-155], N[(180.0 * N[(N[ArcTan[N[(N[(N[(A * 0.0), $MachinePrecision] / B), $MachinePrecision] + N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -5.2e-193], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -8.2e-265], N[(180.0 / N[(Pi / N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 5: 61.6% accurate, 3.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\ \mathbf{if}\;B \leq -5.2 \cdot 10^{-193}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;B \leq -3.8 \cdot 10^{-259}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0}{B}\right)}}\\ \mathbf{elif}\;B \leq 1.7 \cdot 10^{-138}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI))))
   (if (<= B -5.2e-193)
     t_0
     (if (<= B -3.8e-259)
       (/ 180.0 (/ PI (atan (/ 0.0 B))))
       (if (<= B 1.7e-138) t_0 (* 180.0 (/ (atan (/ (- C B) B)) PI)))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
	double tmp;
	if (B <= -5.2e-193) {
		tmp = t_0;
	} else if (B <= -3.8e-259) {
		tmp = 180.0 / (((double) M_PI) / atan((0.0 / B)));
	} else if (B <= 1.7e-138) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
	double tmp;
	if (B <= -5.2e-193) {
		tmp = t_0;
	} else if (B <= -3.8e-259) {
		tmp = 180.0 / (Math.PI / Math.atan((0.0 / B)));
	} else if (B <= 1.7e-138) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi)
	tmp = 0
	if B <= -5.2e-193:
		tmp = t_0
	elif B <= -3.8e-259:
		tmp = 180.0 / (math.pi / math.atan((0.0 / B)))
	elif B <= 1.7e-138:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi))
	tmp = 0.0
	if (B <= -5.2e-193)
		tmp = t_0;
	elseif (B <= -3.8e-259)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(0.0 / B))));
	elseif (B <= 1.7e-138)
		tmp = t_0;
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan((1.0 + ((C - A) / B))) / pi);
	tmp = 0.0;
	if (B <= -5.2e-193)
		tmp = t_0;
	elseif (B <= -3.8e-259)
		tmp = 180.0 / (pi / atan((0.0 / B)));
	elseif (B <= 1.7e-138)
		tmp = t_0;
	else
		tmp = 180.0 * (atan(((C - B) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -5.2e-193], t$95$0, If[LessEqual[B, -3.8e-259], N[(180.0 / N[(Pi / N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.7e-138], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 6: 65.3% accurate, 3.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.1 \cdot 10^{-191}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq -3.8 \cdot 10^{-260}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0}{B}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -2.1e-191)
   (* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI))
   (if (<= B -3.8e-260)
     (/ 180.0 (/ PI (atan (/ 0.0 B))))
     (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.1e-191) {
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
	} else if (B <= -3.8e-260) {
		tmp = 180.0 / (((double) M_PI) / atan((0.0 / B)));
	} 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.1e-191) {
		tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
	} else if (B <= -3.8e-260) {
		tmp = 180.0 / (Math.PI / Math.atan((0.0 / B)));
	} 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.1e-191:
		tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi)
	elif B <= -3.8e-260:
		tmp = 180.0 / (math.pi / math.atan((0.0 / B)))
	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.1e-191)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi));
	elseif (B <= -3.8e-260)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(0.0 / B))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -2.1e-191)
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi);
	elseif (B <= -3.8e-260)
		tmp = 180.0 / (pi / atan((0.0 / B)));
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2.1e-191], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -3.8e-260], N[(180.0 / N[(Pi / N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 65.4% accurate, 3.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -5.2 \cdot 10^{-193}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(B + C\right) - A}{B}\right)}}\\ \mathbf{elif}\;B \leq -9.8 \cdot 10^{-259}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0}{B}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -5.2e-193)
   (/ 180.0 (/ PI (atan (/ (- (+ B C) A) B))))
   (if (<= B -9.8e-259)
     (/ 180.0 (/ PI (atan (/ 0.0 B))))
     (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -5.2e-193) {
		tmp = 180.0 / (((double) M_PI) / atan((((B + C) - A) / B)));
	} else if (B <= -9.8e-259) {
		tmp = 180.0 / (((double) M_PI) / atan((0.0 / B)));
	} 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 <= -5.2e-193) {
		tmp = 180.0 / (Math.PI / Math.atan((((B + C) - A) / B)));
	} else if (B <= -9.8e-259) {
		tmp = 180.0 / (Math.PI / Math.atan((0.0 / B)));
	} else {
		tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -5.2e-193:
		tmp = 180.0 / (math.pi / math.atan((((B + C) - A) / B)))
	elif B <= -9.8e-259:
		tmp = 180.0 / (math.pi / math.atan((0.0 / B)))
	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 <= -5.2e-193)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(B + C) - A) / B))));
	elseif (B <= -9.8e-259)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(0.0 / B))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (B <= -5.2e-193)
		tmp = 180.0 / (pi / atan((((B + C) - A) / B)));
	elseif (B <= -9.8e-259)
		tmp = 180.0 / (pi / atan((0.0 / B)));
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -5.2e-193], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(B + C), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -9.8e-259], N[(180.0 / N[(Pi / N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 8: 47.7% accurate, 3.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -3.85 \cdot 10^{-90}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 1.95 \cdot 10^{-54}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -3.85e-90)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 1.95e-54)
     (* 180.0 (/ (atan (* -2.0 (/ A B))) PI))
     (* 180.0 (/ (atan -1.0) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -3.85e-90) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 1.95e-54) {
		tmp = 180.0 * (atan((-2.0 * (A / B))) / ((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 <= -3.85e-90) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 1.95e-54) {
		tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -3.85e-90:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 1.95e-54:
		tmp = 180.0 * (math.atan((-2.0 * (A / B))) / 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 <= -3.85e-90)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 1.95e-54)
		tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / 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 <= -3.85e-90)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 1.95e-54)
		tmp = 180.0 * (atan((-2.0 * (A / B))) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -3.85e-90], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.95e-54], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $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: 46.7% accurate, 3.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -1.6 \cdot 10^{-92}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 2.65 \cdot 10^{-138}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-\frac{A}{B}\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.6e-92)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 2.65e-138)
     (* 180.0 (/ (atan (- (/ A B))) PI))
     (* 180.0 (/ (atan -1.0) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -1.6e-92) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 2.65e-138) {
		tmp = 180.0 * (atan(-(A / B)) / ((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.6e-92) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 2.65e-138) {
		tmp = 180.0 * (Math.atan(-(A / B)) / 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.6e-92:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 2.65e-138:
		tmp = 180.0 * (math.atan(-(A / B)) / 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.6e-92)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 2.65e-138)
		tmp = Float64(180.0 * Float64(atan(Float64(-Float64(A / B))) / 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.6e-92)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 2.65e-138)
		tmp = 180.0 * (atan(-(A / B)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -1.6e-92], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.65e-138], N[(180.0 * N[(N[ArcTan[(-N[(A / B), $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 10: 47.1% accurate, 3.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -1.3 \cdot 10^{-105}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 5 \cdot 10^{-15}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B}\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.3e-105)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 5e-15)
     (* 180.0 (/ (atan (/ C B)) PI))
     (* 180.0 (/ (atan -1.0) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -1.3e-105) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 5e-15) {
		tmp = 180.0 * (atan((C / B)) / ((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.3e-105) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 5e-15) {
		tmp = 180.0 * (Math.atan((C / B)) / 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.3e-105:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 5e-15:
		tmp = 180.0 * (math.atan((C / B)) / 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.3e-105)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 5e-15)
		tmp = Float64(180.0 * Float64(atan(Float64(C / B)) / 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.3e-105)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 5e-15)
		tmp = 180.0 * (atan((C / B)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -1.3e-105], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5e-15], N[(180.0 * N[(N[ArcTan[N[(C / B), $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 11: 45.3% accurate, 3.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -3 \cdot 10^{-136}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 2.65 \cdot 10^{-185}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0}{B}\right)}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= B -3e-136)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 2.65e-185)
     (/ 180.0 (/ PI (atan (/ 0.0 B))))
     (* 180.0 (/ (atan -1.0) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -3e-136) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 2.65e-185) {
		tmp = 180.0 / (((double) M_PI) / atan((0.0 / B)));
	} 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 <= -3e-136) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 2.65e-185) {
		tmp = 180.0 / (Math.PI / Math.atan((0.0 / B)));
	} else {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -3e-136:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 2.65e-185:
		tmp = 180.0 / (math.pi / math.atan((0.0 / B)))
	else:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (B <= -3e-136)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 2.65e-185)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(0.0 / B))));
	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 <= -3e-136)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 2.65e-185)
		tmp = 180.0 / (pi / atan((0.0 / B)));
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -3e-136], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.65e-185], N[(180.0 / N[(Pi / N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 12: 51.5% accurate, 3.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.2 \cdot 10^{-105}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 13: 40.2% accurate, 3.8× 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 14: 21.1% accurate, 4.0× 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 2024006 
(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)))