ABCF->ab-angle angle

Percentage Accurate: 54.4% → 83.1%

Time: 19.4s

Alternatives: 23

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: 54.4% 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: 83.1% 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)\\ t_1 := \frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\\ \mathbf{if}\;t_0 \leq -1 \cdot 10^{-71}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} t_1}}\\ \mathbf{elif}\;t_0 \leq 0:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(e^{\mathsf{log1p}\left(t_1\right)} + -1\right)}}\\ \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))))))
        (t_1 (/ (- (- C A) (hypot (- A C) B)) B)))
   (if (<= t_0 -1e-71)
     (/ 180.0 (/ PI (atan t_1)))
     (if (<= t_0 0.0)
       (* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
       (/ 180.0 (/ PI (atan (+ (exp (log1p t_1)) -1.0))))))))

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 t_1 = ((C - A) - hypot((A - C), B)) / B;
	double tmp;
	if (t_0 <= -1e-71) {
		tmp = 180.0 / (((double) M_PI) / atan(t_1));
	} else if (t_0 <= 0.0) {
		tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((exp(log1p(t_1)) + -1.0)));
	}
	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 t_1 = ((C - A) - Math.hypot((A - C), B)) / B;
	double tmp;
	if (t_0 <= -1e-71) {
		tmp = 180.0 / (Math.PI / Math.atan(t_1));
	} else if (t_0 <= 0.0) {
		tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((Math.exp(Math.log1p(t_1)) + -1.0)));
	}
	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))))
	t_1 = ((C - A) - math.hypot((A - C), B)) / B
	tmp = 0
	if t_0 <= -1e-71:
		tmp = 180.0 / (math.pi / math.atan(t_1))
	elif t_0 <= 0.0:
		tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi)
	else:
		tmp = 180.0 / (math.pi / math.atan((math.exp(math.log1p(t_1)) + -1.0)))
	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)))))
	t_1 = Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B)
	tmp = 0.0
	if (t_0 <= -1e-71)
		tmp = Float64(180.0 / Float64(pi / atan(t_1)));
	elseif (t_0 <= 0.0)
		tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(exp(log1p(t_1)) + -1.0))));
	end
	return 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]}, Block[{t$95$1 = N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[t$95$0, -1e-71], N[(180.0 / N[(Pi / N[ArcTan[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[Exp[N[Log[1 + t$95$1], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 2: 81.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -1.2 \cdot 10^{+53}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\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 -1.2e+53)
   (* (atan (* 0.5 (/ B A))) (/ 180.0 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 <= -1.2e+53) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((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 <= -1.2e+53) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / 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 <= -1.2e+53:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / 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 <= -1.2e+53)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / 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 <= -1.2e+53)
		tmp = atan((0.5 * (B / A))) * (180.0 / 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, -1.2e+53], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / 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 3: 81.5% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 4: 81.5% accurate, 1.6× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -7e+55)
   (* (atan (* 0.5 (/ B A))) (/ 180.0 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 <= -7e+55) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((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 <= -7e+55) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / 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 <= -7e+55:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / 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 <= -7e+55)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -7e+55)
		tmp = atan((0.5 * (B / A))) * (180.0 / 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, -7e+55], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $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]]

Derivation

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

Alternative 5: 78.3% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -1.3 \cdot 10^{+55}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq 1.15 \cdot 10^{-51}:\\ \;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)\\ \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.3e+55)
   (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
   (if (<= A 1.15e-51)
     (* (/ 180.0 PI) (atan (/ (- C (hypot B C)) B)))
     (* 180.0 (/ (atan (/ (- (- A) (hypot B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -1.3e+55) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= 1.15e-51) {
		tmp = (180.0 / ((double) M_PI)) * atan(((C - hypot(B, C)) / B));
	} 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.3e+55) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= 1.15e-51) {
		tmp = (180.0 / Math.PI) * Math.atan(((C - Math.hypot(B, C)) / B));
	} 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.3e+55:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / math.pi)
	elif A <= 1.15e-51:
		tmp = (180.0 / math.pi) * math.atan(((C - math.hypot(B, C)) / B))
	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.3e+55)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= 1.15e-51)
		tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - hypot(B, C)) / B)));
	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.3e+55)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= 1.15e-51)
		tmp = (180.0 / pi) * atan(((C - hypot(B, C)) / B));
	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.3e+55], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.15e-51], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $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 6: 76.4% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -4 \cdot 10^{+54}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq 6.5 \cdot 10^{+79}:\\ \;\;\;\;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{C - \left(B + A\right)}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -4e+54)
   (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
   (if (<= A 6.5e+79)
     (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
     (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -4e+54) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= 6.5e+79) {
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
	} 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 (A <= -4e+54) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= 6.5e+79) {
		tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
	}
	return tmp;
}

Python

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

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -4e+54)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= 6.5e+79)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi));
	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 (A <= -4e+54)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= 6.5e+79)
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi);
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -4e+54], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 6.5e+79], 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[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 76.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -2.2 \cdot 10^{+53}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq 5 \cdot 10^{+80}:\\ \;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{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 (<= A -2.2e+53)
   (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
   (if (<= A 5e+80)
     (* (/ 180.0 PI) (atan (/ (- C (hypot B C)) B)))
     (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -2.2e+53) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= 5e+80) {
		tmp = (180.0 / ((double) M_PI)) * atan(((C - hypot(B, C)) / 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 (A <= -2.2e+53) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= 5e+80) {
		tmp = (180.0 / Math.PI) * Math.atan(((C - Math.hypot(B, C)) / B));
	} else {
		tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if A <= -2.2e+53:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / math.pi)
	elif A <= 5e+80:
		tmp = (180.0 / math.pi) * math.atan(((C - math.hypot(B, C)) / 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 (A <= -2.2e+53)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= 5e+80)
		tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - hypot(B, C)) / 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 (A <= -2.2e+53)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= 5e+80)
		tmp = (180.0 / pi) * atan(((C - hypot(B, C)) / B));
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -2.2e+53], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 5e+80], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $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: 46.0% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ t_1 := 180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\ t_2 := 180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B}\right)}{\pi}\\ \mathbf{if}\;B \leq -5.2 \cdot 10^{-41}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq -2.55 \cdot 10^{-277}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;B \leq 5.5 \cdot 10^{-246}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;B \leq 3.7 \cdot 10^{-183}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;B \leq 5.2 \cdot 10^{-136}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;B \leq 4.1 \cdot 10^{-129}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;B \leq 1.52 \cdot 10^{-77}:\\ \;\;\;\;t_1\\ \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.5 (/ B A))) PI)))
        (t_1 (* 180.0 (/ (atan (/ 0.0 B)) PI)))
        (t_2 (* 180.0 (/ (atan (/ (- A) B)) PI))))
   (if (<= B -5.2e-41)
     (* 180.0 (/ (atan 1.0) PI))
     (if (<= B -2.55e-277)
       t_0
       (if (<= B 5.5e-246)
         t_2
         (if (<= B 3.7e-183)
           t_1
           (if (<= B 5.2e-136)
             t_2
             (if (<= B 4.1e-129)
               t_0
               (if (<= B 1.52e-77) t_1 (* 180.0 (/ (atan -1.0) PI)))))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
	double t_1 = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
	double t_2 = 180.0 * (atan((-A / B)) / ((double) M_PI));
	double tmp;
	if (B <= -5.2e-41) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= -2.55e-277) {
		tmp = t_0;
	} else if (B <= 5.5e-246) {
		tmp = t_2;
	} else if (B <= 3.7e-183) {
		tmp = t_1;
	} else if (B <= 5.2e-136) {
		tmp = t_2;
	} else if (B <= 4.1e-129) {
		tmp = t_0;
	} else if (B <= 1.52e-77) {
		tmp = t_1;
	} 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.5 * (B / A))) / Math.PI);
	double t_1 = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
	double t_2 = 180.0 * (Math.atan((-A / B)) / Math.PI);
	double tmp;
	if (B <= -5.2e-41) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= -2.55e-277) {
		tmp = t_0;
	} else if (B <= 5.5e-246) {
		tmp = t_2;
	} else if (B <= 3.7e-183) {
		tmp = t_1;
	} else if (B <= 5.2e-136) {
		tmp = t_2;
	} else if (B <= 4.1e-129) {
		tmp = t_0;
	} else if (B <= 1.52e-77) {
		tmp = t_1;
	} 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.5 * (B / A))) / math.pi)
	t_1 = 180.0 * (math.atan((0.0 / B)) / math.pi)
	t_2 = 180.0 * (math.atan((-A / B)) / math.pi)
	tmp = 0
	if B <= -5.2e-41:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= -2.55e-277:
		tmp = t_0
	elif B <= 5.5e-246:
		tmp = t_2
	elif B <= 3.7e-183:
		tmp = t_1
	elif B <= 5.2e-136:
		tmp = t_2
	elif B <= 4.1e-129:
		tmp = t_0
	elif B <= 1.52e-77:
		tmp = t_1
	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.5 * Float64(B / A))) / pi))
	t_1 = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi))
	t_2 = Float64(180.0 * Float64(atan(Float64(Float64(-A) / B)) / pi))
	tmp = 0.0
	if (B <= -5.2e-41)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= -2.55e-277)
		tmp = t_0;
	elseif (B <= 5.5e-246)
		tmp = t_2;
	elseif (B <= 3.7e-183)
		tmp = t_1;
	elseif (B <= 5.2e-136)
		tmp = t_2;
	elseif (B <= 4.1e-129)
		tmp = t_0;
	elseif (B <= 1.52e-77)
		tmp = t_1;
	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.5 * (B / A))) / pi);
	t_1 = 180.0 * (atan((0.0 / B)) / pi);
	t_2 = 180.0 * (atan((-A / B)) / pi);
	tmp = 0.0;
	if (B <= -5.2e-41)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= -2.55e-277)
		tmp = t_0;
	elseif (B <= 5.5e-246)
		tmp = t_2;
	elseif (B <= 3.7e-183)
		tmp = t_1;
	elseif (B <= 5.2e-136)
		tmp = t_2;
	elseif (B <= 4.1e-129)
		tmp = t_0;
	elseif (B <= 1.52e-77)
		tmp = t_1;
	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.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(180.0 * N[(N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -5.2e-41], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2.55e-277], t$95$0, If[LessEqual[B, 5.5e-246], t$95$2, If[LessEqual[B, 3.7e-183], t$95$1, If[LessEqual[B, 5.2e-136], t$95$2, If[LessEqual[B, 4.1e-129], t$95$0, If[LessEqual[B, 1.52e-77], t$95$1, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]

Derivation

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

Alternative 9: 56.2% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{if}\;A \leq -7 \cdot 10^{-82}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq -2 \cdot 10^{-183}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;A \leq -6 \cdot 10^{-222}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{elif}\;A \leq 2.82 \cdot 10^{+54}:\\ \;\;\;\;t_0\\ \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
 (let* ((t_0 (* 180.0 (/ (atan (/ (+ B C) B)) PI))))
   (if (<= A -7e-82)
     (* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
     (if (<= A -2e-183)
       t_0
       (if (<= A -6e-222)
         (* 180.0 (/ (atan -1.0) PI))
         (if (<= A 2.82e+54) t_0 (* 180.0 (/ (atan (* -2.0 (/ A B))) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	double tmp;
	if (A <= -7e-82) {
		tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
	} else if (A <= -2e-183) {
		tmp = t_0;
	} else if (A <= -6e-222) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else if (A <= 2.82e+54) {
		tmp = t_0;
	} 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 t_0 = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	double tmp;
	if (A <= -7e-82) {
		tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
	} else if (A <= -2e-183) {
		tmp = t_0;
	} else if (A <= -6e-222) {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	} else if (A <= 2.82e+54) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	tmp = 0
	if A <= -7e-82:
		tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi)
	elif A <= -2e-183:
		tmp = t_0
	elif A <= -6e-222:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	elif A <= 2.82e+54:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi))
	tmp = 0.0
	if (A <= -7e-82)
		tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi));
	elseif (A <= -2e-183)
		tmp = t_0;
	elseif (A <= -6e-222)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	elseif (A <= 2.82e+54)
		tmp = t_0;
	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)
	t_0 = 180.0 * (atan(((B + C) / B)) / pi);
	tmp = 0.0;
	if (A <= -7e-82)
		tmp = 180.0 * (atan((0.5 * (B / A))) / pi);
	elseif (A <= -2e-183)
		tmp = t_0;
	elseif (A <= -6e-222)
		tmp = 180.0 * (atan(-1.0) / pi);
	elseif (A <= 2.82e+54)
		tmp = t_0;
	else
		tmp = 180.0 * (atan((-2.0 * (A / B))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -7e-82], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2e-183], t$95$0, If[LessEqual[A, -6e-222], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 2.82e+54], t$95$0, 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 10: 58.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{if}\;A \leq -4.9 \cdot 10^{-78}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq -1.7 \cdot 10^{-181}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;A \leq -7.8 \cdot 10^{-223}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{elif}\;A \leq 3.9 \cdot 10^{-53}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ (+ B C) B)) PI))))
   (if (<= A -4.9e-78)
     (* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
     (if (<= A -1.7e-181)
       t_0
       (if (<= A -7.8e-223)
         (* 180.0 (/ (atan -1.0) PI))
         (if (<= A 3.9e-53) t_0 (* 180.0 (/ (atan (/ (- B A) B)) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	double tmp;
	if (A <= -4.9e-78) {
		tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
	} else if (A <= -1.7e-181) {
		tmp = t_0;
	} else if (A <= -7.8e-223) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else if (A <= 3.9e-53) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	double tmp;
	if (A <= -4.9e-78) {
		tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
	} else if (A <= -1.7e-181) {
		tmp = t_0;
	} else if (A <= -7.8e-223) {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	} else if (A <= 3.9e-53) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	tmp = 0
	if A <= -4.9e-78:
		tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi)
	elif A <= -1.7e-181:
		tmp = t_0
	elif A <= -7.8e-223:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	elif A <= 3.9e-53:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi))
	tmp = 0.0
	if (A <= -4.9e-78)
		tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi));
	elseif (A <= -1.7e-181)
		tmp = t_0;
	elseif (A <= -7.8e-223)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	elseif (A <= 3.9e-53)
		tmp = t_0;
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan(((B + C) / B)) / pi);
	tmp = 0.0;
	if (A <= -4.9e-78)
		tmp = 180.0 * (atan((0.5 * (B / A))) / pi);
	elseif (A <= -1.7e-181)
		tmp = t_0;
	elseif (A <= -7.8e-223)
		tmp = 180.0 * (atan(-1.0) / pi);
	elseif (A <= 3.9e-53)
		tmp = t_0;
	else
		tmp = 180.0 * (atan(((B - A) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -4.9e-78], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1.7e-181], t$95$0, If[LessEqual[A, -7.8e-223], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 3.9e-53], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 11: 58.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\ \mathbf{if}\;A \leq -1 \cdot 10^{-76}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq -2 \cdot 10^{-183}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;A \leq -8.8 \cdot 10^{-222}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{elif}\;A \leq 4.2 \cdot 10^{-53}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ (+ B C) B)) PI))))
   (if (<= A -1e-76)
     (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
     (if (<= A -2e-183)
       t_0
       (if (<= A -8.8e-222)
         (* 180.0 (/ (atan -1.0) PI))
         (if (<= A 4.2e-53) t_0 (* 180.0 (/ (atan (/ (- B A) B)) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
	double tmp;
	if (A <= -1e-76) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= -2e-183) {
		tmp = t_0;
	} else if (A <= -8.8e-222) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else if (A <= 4.2e-53) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
	double tmp;
	if (A <= -1e-76) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= -2e-183) {
		tmp = t_0;
	} else if (A <= -8.8e-222) {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	} else if (A <= 4.2e-53) {
		tmp = t_0;
	} else {
		tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((B + C) / B)) / math.pi)
	tmp = 0
	if A <= -1e-76:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / math.pi)
	elif A <= -2e-183:
		tmp = t_0
	elif A <= -8.8e-222:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	elif A <= 4.2e-53:
		tmp = t_0
	else:
		tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi))
	tmp = 0.0
	if (A <= -1e-76)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= -2e-183)
		tmp = t_0;
	elseif (A <= -8.8e-222)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	elseif (A <= 4.2e-53)
		tmp = t_0;
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan(((B + C) / B)) / pi);
	tmp = 0.0;
	if (A <= -1e-76)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= -2e-183)
		tmp = t_0;
	elseif (A <= -8.8e-222)
		tmp = 180.0 * (atan(-1.0) / pi);
	elseif (A <= 4.2e-53)
		tmp = t_0;
	else
		tmp = 180.0 * (atan(((B - A) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -1e-76], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2e-183], t$95$0, If[LessEqual[A, -8.8e-222], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 4.2e-53], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 12: 58.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1} \left(\frac{B + C}{B}\right)\\ \mathbf{if}\;A \leq -2.5 \cdot 10^{-79}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq -2 \cdot 10^{-183}:\\ \;\;\;\;180 \cdot \frac{t_0}{\pi}\\ \mathbf{elif}\;A \leq -4.8 \cdot 10^{-225}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{elif}\;A \leq 1.9 \cdot 10^{-53}:\\ \;\;\;\;\frac{180}{\frac{\pi}{t_0}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (atan (/ (+ B C) B))))
   (if (<= A -2.5e-79)
     (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
     (if (<= A -2e-183)
       (* 180.0 (/ t_0 PI))
       (if (<= A -4.8e-225)
         (* 180.0 (/ (atan -1.0) PI))
         (if (<= A 1.9e-53)
           (/ 180.0 (/ PI t_0))
           (* 180.0 (/ (atan (/ (- B A) B)) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = atan(((B + C) / B));
	double tmp;
	if (A <= -2.5e-79) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= -2e-183) {
		tmp = 180.0 * (t_0 / ((double) M_PI));
	} else if (A <= -4.8e-225) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else if (A <= 1.9e-53) {
		tmp = 180.0 / (((double) M_PI) / t_0);
	} else {
		tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = Math.atan(((B + C) / B));
	double tmp;
	if (A <= -2.5e-79) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= -2e-183) {
		tmp = 180.0 * (t_0 / Math.PI);
	} else if (A <= -4.8e-225) {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	} else if (A <= 1.9e-53) {
		tmp = 180.0 / (Math.PI / t_0);
	} else {
		tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = math.atan(((B + C) / B))
	tmp = 0
	if A <= -2.5e-79:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / math.pi)
	elif A <= -2e-183:
		tmp = 180.0 * (t_0 / math.pi)
	elif A <= -4.8e-225:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	elif A <= 1.9e-53:
		tmp = 180.0 / (math.pi / t_0)
	else:
		tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = atan(Float64(Float64(B + C) / B))
	tmp = 0.0
	if (A <= -2.5e-79)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= -2e-183)
		tmp = Float64(180.0 * Float64(t_0 / pi));
	elseif (A <= -4.8e-225)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	elseif (A <= 1.9e-53)
		tmp = Float64(180.0 / Float64(pi / t_0));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = atan(((B + C) / B));
	tmp = 0.0;
	if (A <= -2.5e-79)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= -2e-183)
		tmp = 180.0 * (t_0 / pi);
	elseif (A <= -4.8e-225)
		tmp = 180.0 * (atan(-1.0) / pi);
	elseif (A <= 1.9e-53)
		tmp = 180.0 / (pi / t_0);
	else
		tmp = 180.0 * (atan(((B - A) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -2.5e-79], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2e-183], N[(180.0 * N[(t$95$0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -4.8e-225], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.9e-53], N[(180.0 / N[(Pi / t$95$0), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 13: 58.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1} \left(\frac{B + C}{B}\right)\\ \mathbf{if}\;A \leq -5.9 \cdot 10^{-80}:\\ \;\;\;\;\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot \frac{180}{\pi}\\ \mathbf{elif}\;A \leq -2.35 \cdot 10^{-164}:\\ \;\;\;\;180 \cdot \frac{t_0}{\pi}\\ \mathbf{elif}\;A \leq -1.9 \cdot 10^{-230}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\ \mathbf{elif}\;A \leq 1.85 \cdot 10^{-53}:\\ \;\;\;\;\frac{180}{\frac{\pi}{t_0}}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (atan (/ (+ B C) B))))
   (if (<= A -5.9e-80)
     (* (atan (* 0.5 (/ B A))) (/ 180.0 PI))
     (if (<= A -2.35e-164)
       (* 180.0 (/ t_0 PI))
       (if (<= A -1.9e-230)
         (/ 180.0 (/ PI (atan (/ (- C B) B))))
         (if (<= A 1.85e-53)
           (/ 180.0 (/ PI t_0))
           (* 180.0 (/ (atan (/ (- B A) B)) PI))))))))

C

double code(double A, double B, double C) {
	double t_0 = atan(((B + C) / B));
	double tmp;
	if (A <= -5.9e-80) {
		tmp = atan((0.5 * (B / A))) * (180.0 / ((double) M_PI));
	} else if (A <= -2.35e-164) {
		tmp = 180.0 * (t_0 / ((double) M_PI));
	} else if (A <= -1.9e-230) {
		tmp = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
	} else if (A <= 1.85e-53) {
		tmp = 180.0 / (((double) M_PI) / t_0);
	} else {
		tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = Math.atan(((B + C) / B));
	double tmp;
	if (A <= -5.9e-80) {
		tmp = Math.atan((0.5 * (B / A))) * (180.0 / Math.PI);
	} else if (A <= -2.35e-164) {
		tmp = 180.0 * (t_0 / Math.PI);
	} else if (A <= -1.9e-230) {
		tmp = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
	} else if (A <= 1.85e-53) {
		tmp = 180.0 / (Math.PI / t_0);
	} else {
		tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = math.atan(((B + C) / B))
	tmp = 0
	if A <= -5.9e-80:
		tmp = math.atan((0.5 * (B / A))) * (180.0 / math.pi)
	elif A <= -2.35e-164:
		tmp = 180.0 * (t_0 / math.pi)
	elif A <= -1.9e-230:
		tmp = 180.0 / (math.pi / math.atan(((C - B) / B)))
	elif A <= 1.85e-53:
		tmp = 180.0 / (math.pi / t_0)
	else:
		tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	t_0 = atan(Float64(Float64(B + C) / B))
	tmp = 0.0
	if (A <= -5.9e-80)
		tmp = Float64(atan(Float64(0.5 * Float64(B / A))) * Float64(180.0 / pi));
	elseif (A <= -2.35e-164)
		tmp = Float64(180.0 * Float64(t_0 / pi));
	elseif (A <= -1.9e-230)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B))));
	elseif (A <= 1.85e-53)
		tmp = Float64(180.0 / Float64(pi / t_0));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = atan(((B + C) / B));
	tmp = 0.0;
	if (A <= -5.9e-80)
		tmp = atan((0.5 * (B / A))) * (180.0 / pi);
	elseif (A <= -2.35e-164)
		tmp = 180.0 * (t_0 / pi);
	elseif (A <= -1.9e-230)
		tmp = 180.0 / (pi / atan(((C - B) / B)));
	elseif (A <= 1.85e-53)
		tmp = 180.0 / (pi / t_0);
	else
		tmp = 180.0 * (atan(((B - A) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -5.9e-80], N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.35e-164], N[(180.0 * N[(t$95$0 / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1.9e-230], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.85e-53], N[(180.0 / N[(Pi / t$95$0), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 14: 61.5% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -1.25 \cdot 10^{-93}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{B + C}{B}\right)}}\\ \mathbf{elif}\;B \leq -1.05 \cdot 10^{-178}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\ \mathbf{elif}\;B \leq -1.52 \cdot 10^{-232}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\ \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 -1.25e-93)
   (/ 180.0 (/ PI (atan (/ (+ B C) B))))
   (if (<= B -1.05e-178)
     (/ (* 180.0 (atan (* 0.5 (/ B A)))) PI)
     (if (<= B -1.52e-232)
       (* 180.0 (/ (atan (/ (- B A) B)) PI))
       (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -1.25e-93) {
		tmp = 180.0 / (((double) M_PI) / atan(((B + C) / B)));
	} else if (B <= -1.05e-178) {
		tmp = (180.0 * atan((0.5 * (B / A)))) / ((double) M_PI);
	} else if (B <= -1.52e-232) {
		tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
	} 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 <= -1.25e-93) {
		tmp = 180.0 / (Math.PI / Math.atan(((B + C) / B)));
	} else if (B <= -1.05e-178) {
		tmp = (180.0 * Math.atan((0.5 * (B / A)))) / Math.PI;
	} else if (B <= -1.52e-232) {
		tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if B <= -1.25e-93:
		tmp = 180.0 / (math.pi / math.atan(((B + C) / B)))
	elif B <= -1.05e-178:
		tmp = (180.0 * math.atan((0.5 * (B / A)))) / math.pi
	elif B <= -1.52e-232:
		tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi)
	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 <= -1.25e-93)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(B + C) / B))));
	elseif (B <= -1.05e-178)
		tmp = Float64(Float64(180.0 * atan(Float64(0.5 * Float64(B / A)))) / pi);
	elseif (B <= -1.52e-232)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi));
	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 <= -1.25e-93)
		tmp = 180.0 / (pi / atan(((B + C) / B)));
	elseif (B <= -1.05e-178)
		tmp = (180.0 * atan((0.5 * (B / A)))) / pi;
	elseif (B <= -1.52e-232)
		tmp = 180.0 * (atan(((B - A) / B)) / pi);
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -1.25e-93], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.05e-178], N[(N[(180.0 * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -1.52e-232], N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $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 15: 46.7% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -7.8 \cdot 10^{-58}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 1.1 \cdot 10^{-228}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 1.3 \cdot 10^{-77}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{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 -7.8e-58)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 1.1e-228)
     (* 180.0 (/ (atan (/ C B)) PI))
     (if (<= B 1.3e-77)
       (* 180.0 (/ (atan (/ 0.0 B)) PI))
       (* 180.0 (/ (atan -1.0) PI))))))

C

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

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -7.8e-58], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.1e-228], N[(180.0 * N[(N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.3e-77], N[(180.0 * N[(N[ArcTan[N[(0.0 / 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 16: 46.6% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -8 \cdot 10^{-59}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 4.8 \cdot 10^{-228}:\\ \;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 6.5 \cdot 10^{-79}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{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 -8e-59)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 4.8e-228)
     (/ (* 180.0 (atan (/ C B))) PI)
     (if (<= B 6.5e-79)
       (* 180.0 (/ (atan (/ 0.0 B)) PI))
       (* 180.0 (/ (atan -1.0) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -8e-59) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 4.8e-228) {
		tmp = (180.0 * atan((C / B))) / ((double) M_PI);
	} else if (B <= 6.5e-79) {
		tmp = 180.0 * (atan((0.0 / 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 <= -8e-59) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 4.8e-228) {
		tmp = (180.0 * Math.atan((C / B))) / Math.PI;
	} else if (B <= 6.5e-79) {
		tmp = 180.0 * (Math.atan((0.0 / 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 <= -8e-59:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 4.8e-228:
		tmp = (180.0 * math.atan((C / B))) / math.pi
	elif B <= 6.5e-79:
		tmp = 180.0 * (math.atan((0.0 / 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 <= -8e-59)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 4.8e-228)
		tmp = Float64(Float64(180.0 * atan(Float64(C / B))) / pi);
	elseif (B <= 6.5e-79)
		tmp = Float64(180.0 * Float64(atan(Float64(0.0 / 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 <= -8e-59)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 4.8e-228)
		tmp = (180.0 * atan((C / B))) / pi;
	elseif (B <= 6.5e-79)
		tmp = 180.0 * (atan((0.0 / B)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -8e-59], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 4.8e-228], N[(N[(180.0 * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 6.5e-79], N[(180.0 * N[(N[ArcTan[N[(0.0 / 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 17: 46.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -4.8 \cdot 10^{-43}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 6 \cdot 10^{-250}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 6.4 \cdot 10^{-79}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{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 -4.8e-43)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 6e-250)
     (* 180.0 (/ (atan (/ (- A) B)) PI))
     (if (<= B 6.4e-79)
       (* 180.0 (/ (atan (/ 0.0 B)) PI))
       (* 180.0 (/ (atan -1.0) PI))))))

C

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

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -4.8e-43], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 6e-250], N[(180.0 * N[(N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 6.4e-79], N[(180.0 * N[(N[ArcTan[N[(0.0 / 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 18: 46.4% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -2.4 \cdot 10^{-41}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 2.5 \cdot 10^{-251}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\ \mathbf{elif}\;B \leq 6.4 \cdot 10^{-79}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{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 -2.4e-41)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 2.5e-251)
     (* 180.0 (/ (atan (* -2.0 (/ A B))) PI))
     (if (<= B 6.4e-79)
       (* 180.0 (/ (atan (/ 0.0 B)) PI))
       (* 180.0 (/ (atan -1.0) PI))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -2.4e-41) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 2.5e-251) {
		tmp = 180.0 * (atan((-2.0 * (A / B))) / ((double) M_PI));
	} else if (B <= 6.4e-79) {
		tmp = 180.0 * (atan((0.0 / 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 <= -2.4e-41) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 2.5e-251) {
		tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
	} else if (B <= 6.4e-79) {
		tmp = 180.0 * (Math.atan((0.0 / 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 <= -2.4e-41:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 2.5e-251:
		tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi)
	elif B <= 6.4e-79:
		tmp = 180.0 * (math.atan((0.0 / 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 <= -2.4e-41)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 2.5e-251)
		tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / pi));
	elseif (B <= 6.4e-79)
		tmp = Float64(180.0 * Float64(atan(Float64(0.0 / 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 <= -2.4e-41)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 2.5e-251)
		tmp = 180.0 * (atan((-2.0 * (A / B))) / pi);
	elseif (B <= 6.4e-79)
		tmp = 180.0 * (atan((0.0 / B)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -2.4e-41], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.5e-251], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 6.4e-79], N[(180.0 * N[(N[ArcTan[N[(0.0 / 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 19: 67.0% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq 10^{-294}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A - B\right)}{B}\right)}{\pi}\\ \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 1e-294)
   (* 180.0 (/ (atan (/ (- C (- A B)) B)) PI))
   (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))

C

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

Python

def code(A, B, C):
	tmp = 0
	if B <= 1e-294:
		tmp = 180.0 * (math.atan(((C - (A - B)) / B)) / math.pi)
	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 <= 1e-294)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A - B)) / B)) / pi));
	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 <= 1e-294)
		tmp = 180.0 * (atan(((C - (A - B)) / B)) / pi);
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, 1e-294], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A - B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $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 20: 66.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq 5 \cdot 10^{-186}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(B + C\right) - A}{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 5e-186)
   (/ 180.0 (/ PI (atan (/ (- (+ B C) A) B))))
   (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= 5e-186) {
		tmp = 180.0 / (((double) M_PI) / atan((((B + C) - A) / 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 <= 5e-186) {
		tmp = 180.0 / (Math.PI / Math.atan((((B + C) - A) / 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 <= 5e-186:
		tmp = 180.0 / (math.pi / math.atan((((B + C) - A) / 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 <= 5e-186)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(B + C) - A) / 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 <= 5e-186)
		tmp = 180.0 / (pi / atan((((B + C) - A) / B)));
	else
		tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, 5e-186], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(B + C), $MachinePrecision] - A), $MachinePrecision] / 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 21: 45.1% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -7.2 \cdot 10^{-100}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 9.3 \cdot 10^{-79}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{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 -7.2e-100)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 9.3e-79)
     (* 180.0 (/ (atan (/ 0.0 B)) PI))
     (* 180.0 (/ (atan -1.0) PI)))))

C

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

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -7.2e-100], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 9.3e-79], N[(180.0 * N[(N[ArcTan[N[(0.0 / 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 22: 40.2% 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 23: 21.3% 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 2023340 
(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)))