ABCF->ab-angle angle

Percentage Accurate: 52.9% → 80.0%

Time: 19.4s

Alternatives: 18

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: 52.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 80.0% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= 18000000000.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(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

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

Wolfram

code[A_, B_, C_] := If[LessEqual[C, 18000000000.0], 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[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 2: 81.3% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 3: 76.9% accurate, 1.6× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -5.4e-9)
   (/ 180.0 (/ PI (atan (/ (- C (hypot B C)) B))))
   (if (<= C 21000000000.0)
     (* 180.0 (/ (atan (/ (- (- A) (hypot B A)) B)) PI))
     (/ 180.0 (/ PI (atan (* -0.5 (/ B C))))))))

C

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

Java

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

Python

def code(A, B, C):
	tmp = 0
	if C <= -5.4e-9:
		tmp = 180.0 / (math.pi / math.atan(((C - math.hypot(B, C)) / B)))
	elif C <= 21000000000.0:
		tmp = 180.0 * (math.atan(((-A - math.hypot(B, A)) / B)) / math.pi)
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -5.4e-9)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(B, C)) / B))));
	elseif (C <= 21000000000.0)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) - hypot(B, A)) / B)) / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -5.4e-9)
		tmp = 180.0 / (pi / atan(((C - hypot(B, C)) / B)));
	elseif (C <= 21000000000.0)
		tmp = 180.0 * (atan(((-A - hypot(B, A)) / B)) / pi);
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 4: 75.2% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -3e+78)
   (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
   (if (<= A 5.6e-45)
     (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
     (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C B) A))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -3e+78) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (A <= 5.6e-45) {
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan(((1.0 / B) * ((C - B) - A))) / ((double) M_PI));
	}
	return tmp;
}

Java

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

Python

def code(A, B, C):
	tmp = 0
	if A <= -3e+78:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif A <= 5.6e-45:
		tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi)
	else:
		tmp = 180.0 * (math.atan(((1.0 / B) * ((C - B) - A))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -3e+78)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (A <= 5.6e-45)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - B) - A))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -3e+78)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (A <= 5.6e-45)
		tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi);
	else
		tmp = 180.0 * (atan(((1.0 / B) * ((C - B) - A))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -3e+78], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 5.6e-45], 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[(1.0 / B), $MachinePrecision] * N[(N[(C - B), $MachinePrecision] - A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 5: 75.2% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -1.5e+80)
   (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
   (if (<= A 5.6e-45)
     (/ 180.0 (/ PI (atan (/ (- C (hypot B C)) B))))
     (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C B) A))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -1.5e+80) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (A <= 5.6e-45) {
		tmp = 180.0 / (((double) M_PI) / atan(((C - hypot(B, C)) / B)));
	} else {
		tmp = 180.0 * (atan(((1.0 / B) * ((C - B) - A))) / ((double) M_PI));
	}
	return tmp;
}

Java

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

Python

def code(A, B, C):
	tmp = 0
	if A <= -1.5e+80:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif A <= 5.6e-45:
		tmp = 180.0 / (math.pi / math.atan(((C - math.hypot(B, C)) / B)))
	else:
		tmp = 180.0 * (math.atan(((1.0 / B) * ((C - B) - A))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -1.5e+80)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (A <= 5.6e-45)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(B, C)) / B))));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - B) - A))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -1.5e+80)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (A <= 5.6e-45)
		tmp = 180.0 / (pi / atan(((C - hypot(B, C)) / B)));
	else
		tmp = 180.0 * (atan(((1.0 / B) * ((C - B) - A))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 6: 57.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{if}\;C \leq -2.75 \cdot 10^{-21}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C + B}{B}\right)}}\\ \mathbf{elif}\;C \leq -8 \cdot 10^{-113}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\ \mathbf{elif}\;C \leq -1.22 \cdot 10^{-188}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;C \leq -1.02 \cdot 10^{-241}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{elif}\;C \leq 2.3 \cdot 10^{-36}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))))
   (if (<= C -2.75e-21)
     (/ 180.0 (/ PI (atan (/ (+ C B) B))))
     (if (<= C -8e-113)
       (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
       (if (<= C -1.22e-188)
         t_0
         (if (<= C -1.02e-241)
           (* 180.0 (/ (atan -1.0) PI))
           (if (<= C 2.3e-36)
             t_0
             (/ 180.0 (/ PI (atan (* -0.5 (/ B C))))))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	double tmp;
	if (C <= -2.75e-21) {
		tmp = 180.0 / (((double) M_PI) / atan(((C + B) / B)));
	} else if (C <= -8e-113) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (C <= -1.22e-188) {
		tmp = t_0;
	} else if (C <= -1.02e-241) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else if (C <= 2.3e-36) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	double tmp;
	if (C <= -2.75e-21) {
		tmp = 180.0 / (Math.PI / Math.atan(((C + B) / B)));
	} else if (C <= -8e-113) {
		tmp = 180.0 * (Math.atan(((B * 0.5) / A)) / Math.PI);
	} else if (C <= -1.22e-188) {
		tmp = t_0;
	} else if (C <= -1.02e-241) {
		tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
	} else if (C <= 2.3e-36) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	tmp = 0
	if C <= -2.75e-21:
		tmp = 180.0 / (math.pi / math.atan(((C + B) / B)))
	elif C <= -8e-113:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif C <= -1.22e-188:
		tmp = t_0
	elif C <= -1.02e-241:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	elif C <= 2.3e-36:
		tmp = t_0
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi))
	tmp = 0.0
	if (C <= -2.75e-21)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C + B) / B))));
	elseif (C <= -8e-113)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (C <= -1.22e-188)
		tmp = t_0;
	elseif (C <= -1.02e-241)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	elseif (C <= 2.3e-36)
		tmp = t_0;
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan((1.0 - (A / B))) / pi);
	tmp = 0.0;
	if (C <= -2.75e-21)
		tmp = 180.0 / (pi / atan(((C + B) / B)));
	elseif (C <= -8e-113)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (C <= -1.22e-188)
		tmp = t_0;
	elseif (C <= -1.02e-241)
		tmp = 180.0 * (atan(-1.0) / pi);
	elseif (C <= 2.3e-36)
		tmp = t_0;
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[C, -2.75e-21], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C + B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -8e-113], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -1.22e-188], t$95$0, If[LessEqual[C, -1.02e-241], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.3e-36], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

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

Alternative 7: 60.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(C - B\right) - A\\ \mathbf{if}\;C \leq 1.45 \cdot 10^{-207}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{t_0}{B}\right)}}\\ \mathbf{elif}\;C \leq 4.6 \cdot 10^{-39}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 15000000000:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot t_0\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (- (- C B) A)))
   (if (<= C 1.45e-207)
     (/ 180.0 (/ PI (atan (/ t_0 B))))
     (if (<= C 4.6e-39)
       (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
       (if (<= C 15000000000.0)
         (* 180.0 (/ (atan (* (/ 1.0 B) t_0)) PI))
         (/ 180.0 (/ PI (atan (* -0.5 (/ B C))))))))))

C

double code(double A, double B, double C) {
	double t_0 = (C - B) - A;
	double tmp;
	if (C <= 1.45e-207) {
		tmp = 180.0 / (((double) M_PI) / atan((t_0 / B)));
	} else if (C <= 4.6e-39) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else if (C <= 15000000000.0) {
		tmp = 180.0 * (atan(((1.0 / B) * t_0)) / ((double) M_PI));
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = (C - B) - A;
	double tmp;
	if (C <= 1.45e-207) {
		tmp = 180.0 / (Math.PI / Math.atan((t_0 / B)));
	} else if (C <= 4.6e-39) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else if (C <= 15000000000.0) {
		tmp = 180.0 * (Math.atan(((1.0 / B) * t_0)) / Math.PI);
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = (C - B) - A
	tmp = 0
	if C <= 1.45e-207:
		tmp = 180.0 / (math.pi / math.atan((t_0 / B)))
	elif C <= 4.6e-39:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	elif C <= 15000000000.0:
		tmp = 180.0 * (math.atan(((1.0 / B) * t_0)) / math.pi)
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(Float64(C - B) - A)
	tmp = 0.0
	if (C <= 1.45e-207)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(t_0 / B))));
	elseif (C <= 4.6e-39)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	elseif (C <= 15000000000.0)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * t_0)) / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = (C - B) - A;
	tmp = 0.0;
	if (C <= 1.45e-207)
		tmp = 180.0 / (pi / atan((t_0 / B)));
	elseif (C <= 4.6e-39)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	elseif (C <= 15000000000.0)
		tmp = 180.0 * (atan(((1.0 / B) * t_0)) / pi);
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(N[(C - B), $MachinePrecision] - A), $MachinePrecision]}, If[LessEqual[C, 1.45e-207], N[(180.0 / N[(Pi / N[ArcTan[N[(t$95$0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.6e-39], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 15000000000.0], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 8: 60.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{\left(-B\right) - A}{B}\right)}{\pi}\\ \mathbf{if}\;C \leq -3.5 \cdot 10^{-57}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C + B}{B}\right)}}\\ \mathbf{elif}\;C \leq -4.3 \cdot 10^{-300}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;C \leq 3.5 \cdot 10^{-39}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 4000000000:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ (- (- B) A) B)) PI))))
   (if (<= C -3.5e-57)
     (/ 180.0 (/ PI (atan (/ (+ C B) B))))
     (if (<= C -4.3e-300)
       t_0
       (if (<= C 3.5e-39)
         (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
         (if (<= C 4000000000.0)
           t_0
           (/ 180.0 (/ PI (atan (* -0.5 (/ B C)))))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((-B - A) / B)) / ((double) M_PI));
	double tmp;
	if (C <= -3.5e-57) {
		tmp = 180.0 / (((double) M_PI) / atan(((C + B) / B)));
	} else if (C <= -4.3e-300) {
		tmp = t_0;
	} else if (C <= 3.5e-39) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else if (C <= 4000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan(((-B - A) / B)) / Math.PI);
	double tmp;
	if (C <= -3.5e-57) {
		tmp = 180.0 / (Math.PI / Math.atan(((C + B) / B)));
	} else if (C <= -4.3e-300) {
		tmp = t_0;
	} else if (C <= 3.5e-39) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else if (C <= 4000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((-B - A) / B)) / math.pi)
	tmp = 0
	if C <= -3.5e-57:
		tmp = 180.0 / (math.pi / math.atan(((C + B) / B)))
	elif C <= -4.3e-300:
		tmp = t_0
	elif C <= 3.5e-39:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	elif C <= 4000000000.0:
		tmp = t_0
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-B) - A) / B)) / pi))
	tmp = 0.0
	if (C <= -3.5e-57)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C + B) / B))));
	elseif (C <= -4.3e-300)
		tmp = t_0;
	elseif (C <= 3.5e-39)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	elseif (C <= 4000000000.0)
		tmp = t_0;
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan(((-B - A) / B)) / pi);
	tmp = 0.0;
	if (C <= -3.5e-57)
		tmp = 180.0 / (pi / atan(((C + B) / B)));
	elseif (C <= -4.3e-300)
		tmp = t_0;
	elseif (C <= 3.5e-39)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	elseif (C <= 4000000000.0)
		tmp = t_0;
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[((-B) - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[C, -3.5e-57], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C + B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -4.3e-300], t$95$0, If[LessEqual[C, 3.5e-39], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4000000000.0], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 9: 61.2% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{\left(-B\right) - A}{B}\right)}{\pi}\\ \mathbf{if}\;C \leq -8.2 \cdot 10^{-95}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq -3 \cdot 10^{-300}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;C \leq 6.6 \cdot 10^{-39}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 9000000000:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (* 180.0 (/ (atan (/ (- (- B) A) B)) PI))))
   (if (<= C -8.2e-95)
     (* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI))
     (if (<= C -3e-300)
       t_0
       (if (<= C 6.6e-39)
         (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
         (if (<= C 9000000000.0)
           t_0
           (/ 180.0 (/ PI (atan (* -0.5 (/ B C)))))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 * (atan(((-B - A) / B)) / ((double) M_PI));
	double tmp;
	if (C <= -8.2e-95) {
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
	} else if (C <= -3e-300) {
		tmp = t_0;
	} else if (C <= 6.6e-39) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else if (C <= 9000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 * (Math.atan(((-B - A) / B)) / Math.PI);
	double tmp;
	if (C <= -8.2e-95) {
		tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
	} else if (C <= -3e-300) {
		tmp = t_0;
	} else if (C <= 6.6e-39) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else if (C <= 9000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 * (math.atan(((-B - A) / B)) / math.pi)
	tmp = 0
	if C <= -8.2e-95:
		tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi)
	elif C <= -3e-300:
		tmp = t_0
	elif C <= 6.6e-39:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	elif C <= 9000000000.0:
		tmp = t_0
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-B) - A) / B)) / pi))
	tmp = 0.0
	if (C <= -8.2e-95)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi));
	elseif (C <= -3e-300)
		tmp = t_0;
	elseif (C <= 6.6e-39)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	elseif (C <= 9000000000.0)
		tmp = t_0;
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 * (atan(((-B - A) / B)) / pi);
	tmp = 0.0;
	if (C <= -8.2e-95)
		tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi);
	elseif (C <= -3e-300)
		tmp = t_0;
	elseif (C <= 6.6e-39)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	elseif (C <= 9000000000.0)
		tmp = t_0;
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[((-B) - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[C, -8.2e-95], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -3e-300], t$95$0, If[LessEqual[C, 6.6e-39], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 9000000000.0], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 10: 58.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -2.75 \cdot 10^{-21}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C + B}{B}\right)}}\\ \mathbf{elif}\;C \leq -2.8 \cdot 10^{-110}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\ \mathbf{elif}\;C \leq -1.35 \cdot 10^{-162}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\ \mathbf{elif}\;C \leq 6 \cdot 10^{-38}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -2.75e-21)
   (/ 180.0 (/ PI (atan (/ (+ C B) B))))
   (if (<= C -2.8e-110)
     (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
     (if (<= C -1.35e-162)
       (/ 180.0 (/ PI (atan (/ (- C B) B))))
       (if (<= C 6e-38)
         (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
         (/ 180.0 (/ PI (atan (* -0.5 (/ B C))))))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.75e-21) {
		tmp = 180.0 / (((double) M_PI) / atan(((C + B) / B)));
	} else if (C <= -2.8e-110) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (C <= -1.35e-162) {
		tmp = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
	} else if (C <= 6e-38) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.75e-21) {
		tmp = 180.0 / (Math.PI / Math.atan(((C + B) / B)));
	} else if (C <= -2.8e-110) {
		tmp = 180.0 * (Math.atan(((B * 0.5) / A)) / Math.PI);
	} else if (C <= -1.35e-162) {
		tmp = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
	} else if (C <= 6e-38) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -2.75e-21:
		tmp = 180.0 / (math.pi / math.atan(((C + B) / B)))
	elif C <= -2.8e-110:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif C <= -1.35e-162:
		tmp = 180.0 / (math.pi / math.atan(((C - B) / B)))
	elif C <= 6e-38:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -2.75e-21)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C + B) / B))));
	elseif (C <= -2.8e-110)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (C <= -1.35e-162)
		tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B))));
	elseif (C <= 6e-38)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -2.75e-21)
		tmp = 180.0 / (pi / atan(((C + B) / B)));
	elseif (C <= -2.8e-110)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (C <= -1.35e-162)
		tmp = 180.0 / (pi / atan(((C - B) / B)));
	elseif (C <= 6e-38)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -2.75e-21], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C + B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -2.8e-110], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -1.35e-162], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6e-38], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 11: 61.0% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(C - B\right) - A}{B}\right)}}\\ \mathbf{if}\;C \leq 1.75 \cdot 10^{-209}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;C \leq 5.6 \cdot 10^{-39}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 10000000000:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (let* ((t_0 (/ 180.0 (/ PI (atan (/ (- (- C B) A) B))))))
   (if (<= C 1.75e-209)
     t_0
     (if (<= C 5.6e-39)
       (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
       (if (<= C 10000000000.0)
         t_0
         (/ 180.0 (/ PI (atan (* -0.5 (/ B C))))))))))

C

double code(double A, double B, double C) {
	double t_0 = 180.0 / (((double) M_PI) / atan((((C - B) - A) / B)));
	double tmp;
	if (C <= 1.75e-209) {
		tmp = t_0;
	} else if (C <= 5.6e-39) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else if (C <= 10000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double t_0 = 180.0 / (Math.PI / Math.atan((((C - B) - A) / B)));
	double tmp;
	if (C <= 1.75e-209) {
		tmp = t_0;
	} else if (C <= 5.6e-39) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else if (C <= 10000000000.0) {
		tmp = t_0;
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	t_0 = 180.0 / (math.pi / math.atan((((C - B) - A) / B)))
	tmp = 0
	if C <= 1.75e-209:
		tmp = t_0
	elif C <= 5.6e-39:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	elif C <= 10000000000.0:
		tmp = t_0
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	t_0 = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - B) - A) / B))))
	tmp = 0.0
	if (C <= 1.75e-209)
		tmp = t_0;
	elseif (C <= 5.6e-39)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	elseif (C <= 10000000000.0)
		tmp = t_0;
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	t_0 = 180.0 / (pi / atan((((C - B) - A) / B)));
	tmp = 0.0;
	if (C <= 1.75e-209)
		tmp = t_0;
	elseif (C <= 5.6e-39)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	elseif (C <= 10000000000.0)
		tmp = t_0;
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C - B), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[C, 1.75e-209], t$95$0, If[LessEqual[C, 5.6e-39], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 10000000000.0], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 12: 54.6% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -2.7 \cdot 10^{+73}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(2 \cdot \frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq -3.7 \cdot 10^{-68}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\ \mathbf{elif}\;C \leq 7 \cdot 10^{-35}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -2.7e+73)
   (* 180.0 (/ (atan (* 2.0 (/ C B))) PI))
   (if (<= C -3.7e-68)
     (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
     (if (<= C 7e-35)
       (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
       (/ 180.0 (/ PI (atan (* -0.5 (/ B C)))))))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.7e+73) {
		tmp = 180.0 * (atan((2.0 * (C / B))) / ((double) M_PI));
	} else if (C <= -3.7e-68) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (C <= 7e-35) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else {
		tmp = 180.0 / (((double) M_PI) / atan((-0.5 * (B / C))));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -2.7e+73) {
		tmp = 180.0 * (Math.atan((2.0 * (C / B))) / Math.PI);
	} else if (C <= -3.7e-68) {
		tmp = 180.0 * (Math.atan(((B * 0.5) / A)) / Math.PI);
	} else if (C <= 7e-35) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else {
		tmp = 180.0 / (Math.PI / Math.atan((-0.5 * (B / C))));
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -2.7e+73:
		tmp = 180.0 * (math.atan((2.0 * (C / B))) / math.pi)
	elif C <= -3.7e-68:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif C <= 7e-35:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	else:
		tmp = 180.0 / (math.pi / math.atan((-0.5 * (B / C))))
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -2.7e+73)
		tmp = Float64(180.0 * Float64(atan(Float64(2.0 * Float64(C / B))) / pi));
	elseif (C <= -3.7e-68)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (C <= 7e-35)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	else
		tmp = Float64(180.0 / Float64(pi / atan(Float64(-0.5 * Float64(B / C)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -2.7e+73)
		tmp = 180.0 * (atan((2.0 * (C / B))) / pi);
	elseif (C <= -3.7e-68)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (C <= 7e-35)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	else
		tmp = 180.0 / (pi / atan((-0.5 * (B / C))));
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -2.7e+73], N[(180.0 * N[(N[ArcTan[N[(2.0 * N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, -3.7e-68], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 7e-35], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 13: 47.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -4.8 \cdot 10^{-110}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 2.25 \cdot 10^{+46}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\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-110)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 2.25e+46)
     (* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
     (* 180.0 (/ (atan -1.0) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (B <= -4.8e-110) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 2.25e+46) {
		tmp = 180.0 * (atan(((A / B) * -2.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 <= -4.8e-110) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 2.25e+46) {
		tmp = 180.0 * (Math.atan(((A / B) * -2.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 <= -4.8e-110:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 2.25e+46:
		tmp = 180.0 * (math.atan(((A / B) * -2.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 <= -4.8e-110)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 2.25e+46)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.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 <= -4.8e-110)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 2.25e+46)
		tmp = 180.0 * (atan(((A / B) * -2.0)) / pi);
	else
		tmp = 180.0 * (atan(-1.0) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[B, -4.8e-110], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.25e+46], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $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 14: 49.0% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;C \leq -8 \cdot 10^{-9}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(2 \cdot \frac{C}{B}\right)}{\pi}\\ \mathbf{elif}\;C \leq 2.75 \cdot 10^{+74}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= C -8e-9)
   (* 180.0 (/ (atan (* 2.0 (/ C B))) PI))
   (if (<= C 2.75e+74)
     (* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
     (* 180.0 (/ (atan (/ 0.0 B)) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (C <= -8e-9) {
		tmp = 180.0 * (atan((2.0 * (C / B))) / ((double) M_PI));
	} else if (C <= 2.75e+74) {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
	}
	return tmp;
}

Java

public static double code(double A, double B, double C) {
	double tmp;
	if (C <= -8e-9) {
		tmp = 180.0 * (Math.atan((2.0 * (C / B))) / Math.PI);
	} else if (C <= 2.75e+74) {
		tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
	} else {
		tmp = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
	}
	return tmp;
}

Python

def code(A, B, C):
	tmp = 0
	if C <= -8e-9:
		tmp = 180.0 * (math.atan((2.0 * (C / B))) / math.pi)
	elif C <= 2.75e+74:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	else:
		tmp = 180.0 * (math.atan((0.0 / B)) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (C <= -8e-9)
		tmp = Float64(180.0 * Float64(atan(Float64(2.0 * Float64(C / B))) / pi));
	elseif (C <= 2.75e+74)
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (C <= -8e-9)
		tmp = 180.0 * (atan((2.0 * (C / B))) / pi);
	elseif (C <= 2.75e+74)
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	else
		tmp = 180.0 * (atan((0.0 / B)) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[C, -8e-9], N[(180.0 * N[(N[ArcTan[N[(2.0 * N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.75e+74], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 15: 53.6% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;A \leq -6.7 \cdot 10^{-307}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\ \mathbf{elif}\;A \leq 2.1 \cdot 10^{-159}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\ \mathbf{else}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\ \end{array} \end{array} \]

FPCore

(FPCore (A B C)
 :precision binary64
 (if (<= A -6.7e-307)
   (* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
   (if (<= A 2.1e-159)
     (* 180.0 (/ (atan -1.0) PI))
     (* 180.0 (/ (atan (- 1.0 (/ A B))) PI)))))

C

double code(double A, double B, double C) {
	double tmp;
	if (A <= -6.7e-307) {
		tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
	} else if (A <= 2.1e-159) {
		tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
	} else {
		tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
	}
	return tmp;
}

Java

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

Python

def code(A, B, C):
	tmp = 0
	if A <= -6.7e-307:
		tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi)
	elif A <= 2.1e-159:
		tmp = 180.0 * (math.atan(-1.0) / math.pi)
	else:
		tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi)
	return tmp

Julia

function code(A, B, C)
	tmp = 0.0
	if (A <= -6.7e-307)
		tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi));
	elseif (A <= 2.1e-159)
		tmp = Float64(180.0 * Float64(atan(-1.0) / pi));
	else
		tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi));
	end
	return tmp
end

MATLAB

function tmp_2 = code(A, B, C)
	tmp = 0.0;
	if (A <= -6.7e-307)
		tmp = 180.0 * (atan(((B * 0.5) / A)) / pi);
	elseif (A <= 2.1e-159)
		tmp = 180.0 * (atan(-1.0) / pi);
	else
		tmp = 180.0 * (atan((1.0 - (A / B))) / pi);
	end
	tmp_2 = tmp;
end

Wolfram

code[A_, B_, C_] := If[LessEqual[A, -6.7e-307], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 2.1e-159], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 16: 44.6% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -9.8 \cdot 10^{-144}:\\ \;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\ \mathbf{elif}\;B \leq 3.8 \cdot 10^{-159}:\\ \;\;\;\;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 -9.8e-144)
   (* 180.0 (/ (atan 1.0) PI))
   (if (<= B 3.8e-159)
     (* 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 <= -9.8e-144) {
		tmp = 180.0 * (atan(1.0) / ((double) M_PI));
	} else if (B <= 3.8e-159) {
		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 <= -9.8e-144) {
		tmp = 180.0 * (Math.atan(1.0) / Math.PI);
	} else if (B <= 3.8e-159) {
		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 <= -9.8e-144:
		tmp = 180.0 * (math.atan(1.0) / math.pi)
	elif B <= 3.8e-159:
		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 <= -9.8e-144)
		tmp = Float64(180.0 * Float64(atan(1.0) / pi));
	elseif (B <= 3.8e-159)
		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 <= -9.8e-144)
		tmp = 180.0 * (atan(1.0) / pi);
	elseif (B <= 3.8e-159)
		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, -9.8e-144], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.8e-159], 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: 40.0% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;B \leq -4 \cdot 10^{-312}:\\ \;\;\;\;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 -4e-312) (* 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 <= -4e-312) {
		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 <= -4e-312) {
		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 <= -4e-312:
		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 <= -4e-312)
		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 <= -4e-312)
		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, -4e-312], 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 18: 20.5% 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 2024003 
(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)))