
(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)))
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));
}
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);
}
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)
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
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
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]
\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}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(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)))
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));
}
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);
}
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)
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
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
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]
\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 (A B C) :precision binary64 (if (<= A -3.2e+106) (/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI) (* 180.0 (/ (atan (/ (- (- C A) (hypot B (- A C))) B)) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.2e+106) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.2e+106) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((((C - A) - Math.hypot(B, (A - C))) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.2e+106: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi else: tmp = 180.0 * (math.atan((((C - A) - math.hypot(B, (A - C))) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.2e+106) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.2e+106) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; else tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.2e+106], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3.2 \cdot 10^{+106}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.1999999999999998e106Initial program 14.3%
associate-*r/14.3%
associate-*l/14.3%
*-un-lft-identity14.3%
unpow214.3%
unpow214.3%
hypot-define45.6%
Applied egg-rr45.6%
Taylor expanded in A around -inf 87.8%
associate-*r/87.8%
distribute-lft-out87.8%
associate-*r*87.8%
metadata-eval87.8%
associate-/l*88.3%
Simplified88.3%
if -3.1999999999999998e106 < A Initial program 61.6%
associate-*l/61.6%
*-lft-identity61.6%
+-commutative61.6%
unpow261.6%
unpow261.6%
hypot-define85.4%
Simplified85.4%
(FPCore (A B C)
:precision binary64
(if (<= A -1.02e+108)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 5.6e-68)
(/ (* 180.0 (atan (/ (- C (hypot B C)) B))) PI)
(* 180.0 (/ (atan (/ (+ A (hypot B A)) (- B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.02e+108) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 5.6e-68) {
tmp = (180.0 * atan(((C - hypot(B, C)) / B))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((A + hypot(B, A)) / -B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.02e+108) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 5.6e-68) {
tmp = (180.0 * Math.atan(((C - Math.hypot(B, C)) / B))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(((A + Math.hypot(B, A)) / -B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.02e+108: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 5.6e-68: tmp = (180.0 * math.atan(((C - math.hypot(B, C)) / B))) / math.pi else: tmp = 180.0 * (math.atan(((A + math.hypot(B, A)) / -B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.02e+108) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 5.6e-68) tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - hypot(B, C)) / B))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(A + hypot(B, A)) / Float64(-B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.02e+108) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 5.6e-68) tmp = (180.0 * atan(((C - hypot(B, C)) / B))) / pi; else tmp = 180.0 * (atan(((A + hypot(B, A)) / -B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.02e+108], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 5.6e-68], N[(N[(180.0 * N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(A + N[Sqrt[B ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.02 \cdot 10^{+108}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 5.6 \cdot 10^{-68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A + \mathsf{hypot}\left(B, A\right)}{-B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.02e108Initial program 14.3%
associate-*r/14.3%
associate-*l/14.3%
*-un-lft-identity14.3%
unpow214.3%
unpow214.3%
hypot-define45.6%
Applied egg-rr45.6%
Taylor expanded in A around -inf 87.8%
associate-*r/87.8%
distribute-lft-out87.8%
associate-*r*87.8%
metadata-eval87.8%
associate-/l*88.3%
Simplified88.3%
if -1.02e108 < A < 5.6000000000000002e-68Initial program 57.1%
associate-*r/57.1%
associate-*l/57.1%
*-un-lft-identity57.1%
unpow257.1%
unpow257.1%
hypot-define83.3%
Applied egg-rr83.3%
Taylor expanded in A around 0 54.4%
unpow254.4%
unpow254.4%
hypot-define80.7%
Simplified80.7%
if 5.6000000000000002e-68 < A Initial program 69.4%
Taylor expanded in C around 0 68.4%
mul-1-neg68.4%
distribute-neg-frac268.4%
+-commutative68.4%
unpow268.4%
unpow268.4%
hypot-define79.9%
Simplified79.9%
(FPCore (A B C)
:precision binary64
(if (<= A -2.7e+106)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 7.4e+50)
(/ (* 180.0 (atan (/ (- C (hypot B C)) B))) PI)
(* 180.0 (/ (atan (+ (/ (- C A) B) -1.0)) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+106) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 7.4e+50) {
tmp = (180.0 * atan(((C - hypot(B, C)) / B))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+106) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 7.4e+50) {
tmp = (180.0 * Math.atan(((C - Math.hypot(B, C)) / B))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((((C - A) / B) + -1.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.7e+106: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 7.4e+50: tmp = (180.0 * math.atan(((C - math.hypot(B, C)) / B))) / math.pi else: tmp = 180.0 * (math.atan((((C - A) / B) + -1.0)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.7e+106) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 7.4e+50) tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - hypot(B, C)) / B))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) / B) + -1.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -2.7e+106) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 7.4e+50) tmp = (180.0 * atan(((C - hypot(B, C)) / B))) / pi; else tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.7e+106], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 7.4e+50], N[(N[(180.0 * N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -2.7 \cdot 10^{+106}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 7.4 \cdot 10^{+50}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B} + -1\right)}{\pi}\\
\end{array}
\end{array}
if A < -2.70000000000000006e106Initial program 14.3%
associate-*r/14.3%
associate-*l/14.3%
*-un-lft-identity14.3%
unpow214.3%
unpow214.3%
hypot-define45.6%
Applied egg-rr45.6%
Taylor expanded in A around -inf 87.8%
associate-*r/87.8%
distribute-lft-out87.8%
associate-*r*87.8%
metadata-eval87.8%
associate-/l*88.3%
Simplified88.3%
if -2.70000000000000006e106 < A < 7.4000000000000001e50Initial program 57.1%
associate-*r/57.1%
associate-*l/57.1%
*-un-lft-identity57.1%
unpow257.1%
unpow257.1%
hypot-define82.8%
Applied egg-rr82.8%
Taylor expanded in A around 0 52.8%
unpow252.8%
unpow252.8%
hypot-define78.5%
Simplified78.5%
if 7.4000000000000001e50 < A Initial program 74.5%
Taylor expanded in B around inf 81.0%
Taylor expanded in B around 0 81.0%
associate--r+81.0%
sub-neg81.0%
mul-1-neg81.0%
mul-1-neg81.0%
sub-neg81.0%
div-sub81.0%
sub-neg81.0%
*-inverses81.0%
metadata-eval81.0%
Simplified81.0%
(FPCore (A B C)
:precision binary64
(if (<= A -1.15e+107)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 1.1e+51)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(* 180.0 (/ (atan (+ (/ (- C A) B) -1.0)) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.15e+107) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 1.1e+51) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.15e+107) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 1.1e+51) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((((C - A) / B) + -1.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.15e+107: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 1.1e+51: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) else: tmp = 180.0 * (math.atan((((C - A) / B) + -1.0)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.15e+107) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 1.1e+51) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) / B) + -1.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.15e+107) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 1.1e+51) tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); else tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.15e+107], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.1e+51], 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[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.15 \cdot 10^{+107}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.1 \cdot 10^{+51}:\\
\;\;\;\;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 - A}{B} + -1\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.15e107Initial program 14.3%
associate-*r/14.3%
associate-*l/14.3%
*-un-lft-identity14.3%
unpow214.3%
unpow214.3%
hypot-define45.6%
Applied egg-rr45.6%
Taylor expanded in A around -inf 87.8%
associate-*r/87.8%
distribute-lft-out87.8%
associate-*r*87.8%
metadata-eval87.8%
associate-/l*88.3%
Simplified88.3%
if -1.15e107 < A < 1.09999999999999996e51Initial program 57.1%
Taylor expanded in A around 0 52.8%
unpow252.8%
unpow252.8%
hypot-define78.5%
Simplified78.5%
if 1.09999999999999996e51 < A Initial program 74.5%
Taylor expanded in B around inf 81.0%
Taylor expanded in B around 0 81.0%
associate--r+81.0%
sub-neg81.0%
mul-1-neg81.0%
mul-1-neg81.0%
sub-neg81.0%
div-sub81.0%
sub-neg81.0%
*-inverses81.0%
metadata-eval81.0%
Simplified81.0%
(FPCore (A B C) :precision binary64 (if (<= A -8.5e+100) (/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI) (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -8.5e+100) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -8.5e+100) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -8.5e+100: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi else: tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -8.5e+100) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / 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
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -8.5e+100) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; else tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -8.5e+100], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -8.5 \cdot 10^{+100}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{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}
if A < -8.50000000000000043e100Initial program 16.3%
associate-*r/16.3%
associate-*l/16.3%
*-un-lft-identity16.3%
unpow216.3%
unpow216.3%
hypot-define46.9%
Applied egg-rr46.9%
Taylor expanded in A around -inf 88.1%
associate-*r/88.1%
distribute-lft-out88.1%
associate-*r*88.1%
metadata-eval88.1%
associate-/l*88.6%
Simplified88.6%
if -8.50000000000000043e100 < A Initial program 61.4%
Simplified84.9%
(FPCore (A B C)
:precision binary64
(if (<= B -5.1e-230)
(* 180.0 (/ (atan (* (/ 1.0 B) (+ B (- C A)))) PI))
(if (<= B 1.95e-302)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= B 7.8e-244)
(* 180.0 (/ (atan (/ (- (* A (- -1.0 (* 0.5 (/ A B)))) B) B)) PI))
(if (<= B 3.5e-230)
(/ (* 180.0 (atan 0.0)) PI)
(if (<= B 4.6e-116)
(/ (* 180.0 (atan (+ (/ (- C A) B) -1.0))) PI)
(if (<= B 3.4e-75)
(/ (* 180.0 (atan (/ (* 0.5 B) A))) PI)
(* 180.0 (/ (atan (+ (/ C B) (- -1.0 (/ A B)))) PI)))))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5.1e-230) {
tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / ((double) M_PI));
} else if (B <= 1.95e-302) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (B <= 7.8e-244) {
tmp = 180.0 * (atan((((A * (-1.0 - (0.5 * (A / B)))) - B) / B)) / ((double) M_PI));
} else if (B <= 3.5e-230) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else if (B <= 4.6e-116) {
tmp = (180.0 * atan((((C - A) / B) + -1.0))) / ((double) M_PI);
} else if (B <= 3.4e-75) {
tmp = (180.0 * atan(((0.5 * B) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -5.1e-230) {
tmp = 180.0 * (Math.atan(((1.0 / B) * (B + (C - A)))) / Math.PI);
} else if (B <= 1.95e-302) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (B <= 7.8e-244) {
tmp = 180.0 * (Math.atan((((A * (-1.0 - (0.5 * (A / B)))) - B) / B)) / Math.PI);
} else if (B <= 3.5e-230) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else if (B <= 4.6e-116) {
tmp = (180.0 * Math.atan((((C - A) / B) + -1.0))) / Math.PI;
} else if (B <= 3.4e-75) {
tmp = (180.0 * Math.atan(((0.5 * B) / A))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(((C / B) + (-1.0 - (A / B)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5.1e-230: tmp = 180.0 * (math.atan(((1.0 / B) * (B + (C - A)))) / math.pi) elif B <= 1.95e-302: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif B <= 7.8e-244: tmp = 180.0 * (math.atan((((A * (-1.0 - (0.5 * (A / B)))) - B) / B)) / math.pi) elif B <= 3.5e-230: tmp = (180.0 * math.atan(0.0)) / math.pi elif B <= 4.6e-116: tmp = (180.0 * math.atan((((C - A) / B) + -1.0))) / math.pi elif B <= 3.4e-75: tmp = (180.0 * math.atan(((0.5 * B) / A))) / math.pi else: tmp = 180.0 * (math.atan(((C / B) + (-1.0 - (A / B)))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5.1e-230) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(B + Float64(C - A)))) / pi)); elseif (B <= 1.95e-302) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (B <= 7.8e-244) tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(A * Float64(-1.0 - Float64(0.5 * Float64(A / B)))) - B) / B)) / pi)); elseif (B <= 3.5e-230) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); elseif (B <= 4.6e-116) tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - A) / B) + -1.0))) / pi); elseif (B <= 3.4e-75) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * B) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + Float64(-1.0 - Float64(A / B)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5.1e-230) tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / pi); elseif (B <= 1.95e-302) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (B <= 7.8e-244) tmp = 180.0 * (atan((((A * (-1.0 - (0.5 * (A / B)))) - B) / B)) / pi); elseif (B <= 3.5e-230) tmp = (180.0 * atan(0.0)) / pi; elseif (B <= 4.6e-116) tmp = (180.0 * atan((((C - A) / B) + -1.0))) / pi; elseif (B <= 3.4e-75) tmp = (180.0 * atan(((0.5 * B) / A))) / pi; else tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5.1e-230], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(B + N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.95e-302], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 7.8e-244], N[(180.0 * N[(N[ArcTan[N[(N[(N[(A * N[(-1.0 - N[(0.5 * N[(A / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.5e-230], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 4.6e-116], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 3.4e-75], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5.1 \cdot 10^{-230}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(B + \left(C - A\right)\right)\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.95 \cdot 10^{-302}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;B \leq 7.8 \cdot 10^{-244}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A \cdot \left(-1 - 0.5 \cdot \frac{A}{B}\right) - B}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.5 \cdot 10^{-230}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{elif}\;B \leq 4.6 \cdot 10^{-116}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - A}{B} + -1\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.4 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + \left(-1 - \frac{A}{B}\right)\right)}{\pi}\\
\end{array}
\end{array}
if B < -5.0999999999999999e-230Initial program 53.0%
Taylor expanded in B around -inf 70.0%
neg-mul-170.0%
Simplified70.0%
if -5.0999999999999999e-230 < B < 1.95e-302Initial program 62.1%
associate-*r/62.1%
associate-*l/62.1%
*-un-lft-identity62.1%
unpow262.1%
unpow262.1%
hypot-define74.8%
Applied egg-rr74.8%
Taylor expanded in A around -inf 61.6%
associate-*r/61.6%
distribute-lft-out61.6%
associate-*r*61.6%
metadata-eval61.6%
associate-/l*66.1%
Simplified66.1%
if 1.95e-302 < B < 7.7999999999999998e-244Initial program 75.9%
Taylor expanded in C around 0 63.6%
mul-1-neg63.6%
distribute-neg-frac263.6%
+-commutative63.6%
unpow263.6%
unpow263.6%
hypot-define75.9%
Simplified75.9%
Taylor expanded in A around 0 76.1%
if 7.7999999999999998e-244 < B < 3.49999999999999988e-230Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 3.49999999999999988e-230 < B < 4.60000000000000003e-116Initial program 62.7%
associate-*r/62.7%
associate-*l/62.6%
*-un-lft-identity62.6%
unpow262.6%
unpow262.6%
hypot-define84.2%
Applied egg-rr84.2%
Taylor expanded in B around inf 48.6%
+-commutative48.6%
associate--r+48.6%
div-sub59.9%
sub-neg59.9%
metadata-eval59.9%
Simplified59.9%
if 4.60000000000000003e-116 < B < 3.40000000000000015e-75Initial program 19.4%
associate-*r/19.4%
associate-*l/19.4%
*-un-lft-identity19.4%
unpow219.4%
unpow219.4%
hypot-define60.8%
Applied egg-rr60.8%
Taylor expanded in A around -inf 60.0%
associate-*r/60.0%
Simplified60.0%
if 3.40000000000000015e-75 < B Initial program 55.1%
Taylor expanded in B around inf 77.8%
Final simplification72.0%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (+ (/ C B) (- -1.0 (/ A B)))) PI))))
(if (<= B -9e-229)
(* 180.0 (/ (atan (* (/ 1.0 B) (+ B (- C A)))) PI))
(if (<= B 2.35e-299)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= B 7.2e-244)
t_0
(if (<= B 2.55e-231)
(/ (* 180.0 (atan 0.0)) PI)
(if (<= B 8e-118)
(/ (* 180.0 (atan (+ (/ (- C A) B) -1.0))) PI)
(if (<= B 3.4e-75)
(/ (* 180.0 (atan (/ (* 0.5 B) A))) PI)
t_0))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / ((double) M_PI));
double tmp;
if (B <= -9e-229) {
tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / ((double) M_PI));
} else if (B <= 2.35e-299) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (B <= 7.2e-244) {
tmp = t_0;
} else if (B <= 2.55e-231) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else if (B <= 8e-118) {
tmp = (180.0 * atan((((C - A) / B) + -1.0))) / ((double) M_PI);
} else if (B <= 3.4e-75) {
tmp = (180.0 * atan(((0.5 * B) / A))) / ((double) M_PI);
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C / B) + (-1.0 - (A / B)))) / Math.PI);
double tmp;
if (B <= -9e-229) {
tmp = 180.0 * (Math.atan(((1.0 / B) * (B + (C - A)))) / Math.PI);
} else if (B <= 2.35e-299) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (B <= 7.2e-244) {
tmp = t_0;
} else if (B <= 2.55e-231) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else if (B <= 8e-118) {
tmp = (180.0 * Math.atan((((C - A) / B) + -1.0))) / Math.PI;
} else if (B <= 3.4e-75) {
tmp = (180.0 * Math.atan(((0.5 * B) / A))) / Math.PI;
} else {
tmp = t_0;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C / B) + (-1.0 - (A / B)))) / math.pi) tmp = 0 if B <= -9e-229: tmp = 180.0 * (math.atan(((1.0 / B) * (B + (C - A)))) / math.pi) elif B <= 2.35e-299: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif B <= 7.2e-244: tmp = t_0 elif B <= 2.55e-231: tmp = (180.0 * math.atan(0.0)) / math.pi elif B <= 8e-118: tmp = (180.0 * math.atan((((C - A) / B) + -1.0))) / math.pi elif B <= 3.4e-75: tmp = (180.0 * math.atan(((0.5 * B) / A))) / math.pi else: tmp = t_0 return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + Float64(-1.0 - Float64(A / B)))) / pi)) tmp = 0.0 if (B <= -9e-229) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(B + Float64(C - A)))) / pi)); elseif (B <= 2.35e-299) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (B <= 7.2e-244) tmp = t_0; elseif (B <= 2.55e-231) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); elseif (B <= 8e-118) tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - A) / B) + -1.0))) / pi); elseif (B <= 3.4e-75) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * B) / A))) / pi); else tmp = t_0; end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / pi); tmp = 0.0; if (B <= -9e-229) tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / pi); elseif (B <= 2.35e-299) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (B <= 7.2e-244) tmp = t_0; elseif (B <= 2.55e-231) tmp = (180.0 * atan(0.0)) / pi; elseif (B <= 8e-118) tmp = (180.0 * atan((((C - A) / B) + -1.0))) / pi; elseif (B <= 3.4e-75) tmp = (180.0 * atan(((0.5 * B) / A))) / pi; else tmp = t_0; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -9e-229], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(B + N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.35e-299], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 7.2e-244], t$95$0, If[LessEqual[B, 2.55e-231], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 8e-118], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 3.4e-75], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], t$95$0]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + \left(-1 - \frac{A}{B}\right)\right)}{\pi}\\
\mathbf{if}\;B \leq -9 \cdot 10^{-229}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(B + \left(C - A\right)\right)\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.35 \cdot 10^{-299}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;B \leq 7.2 \cdot 10^{-244}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 2.55 \cdot 10^{-231}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{elif}\;B \leq 8 \cdot 10^{-118}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - A}{B} + -1\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.4 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if B < -9.0000000000000004e-229Initial program 53.0%
Taylor expanded in B around -inf 70.0%
neg-mul-170.0%
Simplified70.0%
if -9.0000000000000004e-229 < B < 2.3499999999999999e-299Initial program 62.1%
associate-*r/62.1%
associate-*l/62.1%
*-un-lft-identity62.1%
unpow262.1%
unpow262.1%
hypot-define74.8%
Applied egg-rr74.8%
Taylor expanded in A around -inf 61.6%
associate-*r/61.6%
distribute-lft-out61.6%
associate-*r*61.6%
metadata-eval61.6%
associate-/l*66.1%
Simplified66.1%
if 2.3499999999999999e-299 < B < 7.1999999999999995e-244 or 3.40000000000000015e-75 < B Initial program 56.8%
Taylor expanded in B around inf 77.6%
if 7.1999999999999995e-244 < B < 2.55e-231Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 2.55e-231 < B < 7.99999999999999988e-118Initial program 62.7%
associate-*r/62.7%
associate-*l/62.6%
*-un-lft-identity62.6%
unpow262.6%
unpow262.6%
hypot-define84.2%
Applied egg-rr84.2%
Taylor expanded in B around inf 48.6%
+-commutative48.6%
associate--r+48.6%
div-sub59.9%
sub-neg59.9%
metadata-eval59.9%
Simplified59.9%
if 7.99999999999999988e-118 < B < 3.40000000000000015e-75Initial program 19.4%
associate-*r/19.4%
associate-*l/19.4%
*-un-lft-identity19.4%
unpow219.4%
unpow219.4%
hypot-define60.8%
Applied egg-rr60.8%
Taylor expanded in A around -inf 60.0%
associate-*r/60.0%
Simplified60.0%
Final simplification72.0%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))
(t_1 (* (atan (- -1.0 (/ A B))) (/ 180.0 PI))))
(if (<= C -3.5e-95)
(* 180.0 (/ (atan (/ (- C B) B)) PI))
(if (<= C 2.1e-280)
(* 180.0 (/ (atan (/ (- B A) B)) PI))
(if (<= C 4.4e-91)
t_1
(if (<= C 3.5e-61)
t_0
(if (<= C 2.6e-45)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= C 1.1e+47) t_1 t_0))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
double t_1 = atan((-1.0 - (A / B))) * (180.0 / ((double) M_PI));
double tmp;
if (C <= -3.5e-95) {
tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
} else if (C <= 2.1e-280) {
tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
} else if (C <= 4.4e-91) {
tmp = t_1;
} else if (C <= 3.5e-61) {
tmp = t_0;
} else if (C <= 2.6e-45) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (C <= 1.1e+47) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
double t_1 = Math.atan((-1.0 - (A / B))) * (180.0 / Math.PI);
double tmp;
if (C <= -3.5e-95) {
tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
} else if (C <= 2.1e-280) {
tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
} else if (C <= 4.4e-91) {
tmp = t_1;
} else if (C <= 3.5e-61) {
tmp = t_0;
} else if (C <= 2.6e-45) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (C <= 1.1e+47) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) t_1 = math.atan((-1.0 - (A / B))) * (180.0 / math.pi) tmp = 0 if C <= -3.5e-95: tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi) elif C <= 2.1e-280: tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi) elif C <= 4.4e-91: tmp = t_1 elif C <= 3.5e-61: tmp = t_0 elif C <= 2.6e-45: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif C <= 1.1e+47: tmp = t_1 else: tmp = t_0 return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)) t_1 = Float64(atan(Float64(-1.0 - Float64(A / B))) * Float64(180.0 / pi)) tmp = 0.0 if (C <= -3.5e-95) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi)); elseif (C <= 2.1e-280) tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi)); elseif (C <= 4.4e-91) tmp = t_1; elseif (C <= 3.5e-61) tmp = t_0; elseif (C <= 2.6e-45) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (C <= 1.1e+47) tmp = t_1; else tmp = t_0; end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan((-0.5 * (B / C))) / pi); t_1 = atan((-1.0 - (A / B))) * (180.0 / pi); tmp = 0.0; if (C <= -3.5e-95) tmp = 180.0 * (atan(((C - B) / B)) / pi); elseif (C <= 2.1e-280) tmp = 180.0 * (atan(((B - A) / B)) / pi); elseif (C <= 4.4e-91) tmp = t_1; elseif (C <= 3.5e-61) tmp = t_0; elseif (C <= 2.6e-45) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (C <= 1.1e+47) tmp = t_1; else tmp = t_0; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[C, -3.5e-95], N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.1e-280], N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.4e-91], t$95$1, If[LessEqual[C, 3.5e-61], t$95$0, If[LessEqual[C, 2.6e-45], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 1.1e+47], t$95$1, t$95$0]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
t_1 := \tan^{-1} \left(-1 - \frac{A}{B}\right) \cdot \frac{180}{\pi}\\
\mathbf{if}\;C \leq -3.5 \cdot 10^{-95}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.1 \cdot 10^{-280}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 4.4 \cdot 10^{-91}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;C \leq 3.5 \cdot 10^{-61}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;C \leq 2.6 \cdot 10^{-45}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;C \leq 1.1 \cdot 10^{+47}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if C < -3.4999999999999997e-95Initial program 70.1%
Taylor expanded in B around inf 72.7%
Taylor expanded in A around 0 70.1%
if -3.4999999999999997e-95 < C < 2.10000000000000001e-280Initial program 63.8%
Taylor expanded in B around -inf 60.3%
neg-mul-160.3%
Simplified60.3%
Taylor expanded in C around 0 58.5%
if 2.10000000000000001e-280 < C < 4.4000000000000002e-91 or 2.59999999999999987e-45 < C < 1.1e47Initial program 51.8%
associate-*r/51.8%
associate-*l/51.8%
*-un-lft-identity51.8%
unpow251.8%
unpow251.8%
hypot-define77.6%
Applied egg-rr77.6%
Taylor expanded in B around inf 55.5%
+-commutative55.5%
associate--r+55.5%
div-sub55.5%
sub-neg55.5%
metadata-eval55.5%
Simplified55.5%
Taylor expanded in C around 0 55.6%
distribute-lft-in55.6%
metadata-eval55.6%
mul-1-neg55.6%
unsub-neg55.6%
Simplified55.6%
Taylor expanded in A around 0 55.6%
associate-*r/55.6%
*-commutative55.6%
+-commutative55.6%
distribute-neg-in55.6%
neg-mul-155.6%
sub-neg55.6%
sub-neg55.6%
metadata-eval55.6%
+-commutative55.6%
neg-mul-155.6%
sub-neg55.6%
associate-/l*55.6%
Simplified55.6%
if 4.4000000000000002e-91 < C < 3.5000000000000003e-61 or 1.1e47 < C Initial program 22.3%
Taylor expanded in C around inf 70.7%
Taylor expanded in A around inf 70.7%
if 3.5000000000000003e-61 < C < 2.59999999999999987e-45Initial program 61.3%
Taylor expanded in A around -inf 83.4%
associate-*r/83.4%
Simplified83.4%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (+ B C) B)) PI)))
(t_1 (* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))))
(if (<= A -2.3e+94)
t_1
(if (<= A -390000000.0)
t_0
(if (<= A -6e-70)
t_1
(if (<= A -1.25e-261)
t_0
(if (<= A 6.5e-296)
(* 180.0 (/ (atan -1.0) PI))
(if (<= A 1.2e-26)
t_0
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
double t_1 = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
double tmp;
if (A <= -2.3e+94) {
tmp = t_1;
} else if (A <= -390000000.0) {
tmp = t_0;
} else if (A <= -6e-70) {
tmp = t_1;
} else if (A <= -1.25e-261) {
tmp = t_0;
} else if (A <= 6.5e-296) {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
} else if (A <= 1.2e-26) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
double t_1 = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
double tmp;
if (A <= -2.3e+94) {
tmp = t_1;
} else if (A <= -390000000.0) {
tmp = t_0;
} else if (A <= -6e-70) {
tmp = t_1;
} else if (A <= -1.25e-261) {
tmp = t_0;
} else if (A <= 6.5e-296) {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
} else if (A <= 1.2e-26) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((B + C) / B)) / math.pi) t_1 = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) tmp = 0 if A <= -2.3e+94: tmp = t_1 elif A <= -390000000.0: tmp = t_0 elif A <= -6e-70: tmp = t_1 elif A <= -1.25e-261: tmp = t_0 elif A <= 6.5e-296: tmp = 180.0 * (math.atan(-1.0) / math.pi) elif A <= 1.2e-26: tmp = t_0 else: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi)) t_1 = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)) tmp = 0.0 if (A <= -2.3e+94) tmp = t_1; elseif (A <= -390000000.0) tmp = t_0; elseif (A <= -6e-70) tmp = t_1; elseif (A <= -1.25e-261) tmp = t_0; elseif (A <= 6.5e-296) tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); elseif (A <= 1.2e-26) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((B + C) / B)) / pi); t_1 = 180.0 * (atan(((0.5 * B) / A)) / pi); tmp = 0.0; if (A <= -2.3e+94) tmp = t_1; elseif (A <= -390000000.0) tmp = t_0; elseif (A <= -6e-70) tmp = t_1; elseif (A <= -1.25e-261) tmp = t_0; elseif (A <= 6.5e-296) tmp = 180.0 * (atan(-1.0) / pi); elseif (A <= 1.2e-26) tmp = t_0; else tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); end tmp_2 = tmp; end
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]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -2.3e+94], t$95$1, If[LessEqual[A, -390000000.0], t$95$0, If[LessEqual[A, -6e-70], t$95$1, If[LessEqual[A, -1.25e-261], t$95$0, If[LessEqual[A, 6.5e-296], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.2e-26], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\
t_1 := 180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{if}\;A \leq -2.3 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;A \leq -390000000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;A \leq -6 \cdot 10^{-70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;A \leq -1.25 \cdot 10^{-261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;A \leq 6.5 \cdot 10^{-296}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\mathbf{elif}\;A \leq 1.2 \cdot 10^{-26}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\end{array}
\end{array}
if A < -2.3e94 or -3.9e8 < A < -6.0000000000000003e-70Initial program 21.1%
Taylor expanded in A around -inf 77.7%
associate-*r/77.7%
Simplified77.7%
if -2.3e94 < A < -3.9e8 or -6.0000000000000003e-70 < A < -1.24999999999999995e-261 or 6.49999999999999963e-296 < A < 1.2e-26Initial program 59.0%
Taylor expanded in B around -inf 55.8%
neg-mul-155.8%
Simplified55.8%
Taylor expanded in A around 0 53.2%
if -1.24999999999999995e-261 < A < 6.49999999999999963e-296Initial program 57.5%
Taylor expanded in B around inf 64.2%
if 1.2e-26 < A Initial program 71.7%
Taylor expanded in A around inf 63.9%
Final simplification62.0%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan -1.0) PI))))
(if (<= A -6.5e-239)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= A 1.22e-294)
t_0
(if (<= A 2.6e-250)
(* 180.0 (/ (atan (* (/ C B) 2.0)) PI))
(if (<= A 1.3e-208)
t_0
(if (<= A 6.5e-31)
(* 180.0 (/ (atan 1.0) PI))
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI)))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(-1.0) / ((double) M_PI));
double tmp;
if (A <= -6.5e-239) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (A <= 1.22e-294) {
tmp = t_0;
} else if (A <= 2.6e-250) {
tmp = 180.0 * (atan(((C / B) * 2.0)) / ((double) M_PI));
} else if (A <= 1.3e-208) {
tmp = t_0;
} else if (A <= 6.5e-31) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(-1.0) / Math.PI);
double tmp;
if (A <= -6.5e-239) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (A <= 1.22e-294) {
tmp = t_0;
} else if (A <= 2.6e-250) {
tmp = 180.0 * (Math.atan(((C / B) * 2.0)) / Math.PI);
} else if (A <= 1.3e-208) {
tmp = t_0;
} else if (A <= 6.5e-31) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(-1.0) / math.pi) tmp = 0 if A <= -6.5e-239: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif A <= 1.22e-294: tmp = t_0 elif A <= 2.6e-250: tmp = 180.0 * (math.atan(((C / B) * 2.0)) / math.pi) elif A <= 1.3e-208: tmp = t_0 elif A <= 6.5e-31: tmp = 180.0 * (math.atan(1.0) / math.pi) else: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(-1.0) / pi)) tmp = 0.0 if (A <= -6.5e-239) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (A <= 1.22e-294) tmp = t_0; elseif (A <= 2.6e-250) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) * 2.0)) / pi)); elseif (A <= 1.3e-208) tmp = t_0; elseif (A <= 6.5e-31) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(-1.0) / pi); tmp = 0.0; if (A <= -6.5e-239) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (A <= 1.22e-294) tmp = t_0; elseif (A <= 2.6e-250) tmp = 180.0 * (atan(((C / B) * 2.0)) / pi); elseif (A <= 1.3e-208) tmp = t_0; elseif (A <= 6.5e-31) tmp = 180.0 * (atan(1.0) / pi); else tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -6.5e-239], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.22e-294], t$95$0, If[LessEqual[A, 2.6e-250], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.3e-208], t$95$0, If[LessEqual[A, 6.5e-31], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\mathbf{if}\;A \leq -6.5 \cdot 10^{-239}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.22 \cdot 10^{-294}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;A \leq 2.6 \cdot 10^{-250}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} \cdot 2\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.3 \cdot 10^{-208}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;A \leq 6.5 \cdot 10^{-31}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\end{array}
\end{array}
if A < -6.5000000000000003e-239Initial program 38.0%
Taylor expanded in A around -inf 53.2%
associate-*r/53.2%
Simplified53.2%
if -6.5000000000000003e-239 < A < 1.21999999999999995e-294 or 2.60000000000000008e-250 < A < 1.30000000000000008e-208Initial program 55.7%
Taylor expanded in B around inf 54.8%
if 1.21999999999999995e-294 < A < 2.60000000000000008e-250Initial program 82.3%
Taylor expanded in C around -inf 61.3%
if 1.30000000000000008e-208 < A < 6.49999999999999967e-31Initial program 63.2%
Taylor expanded in B around -inf 40.5%
if 6.49999999999999967e-31 < A Initial program 71.7%
Taylor expanded in A around inf 63.9%
Final simplification54.9%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (+ (/ (- C A) B) 1.0)) PI))))
(if (<= B 8.6e-244)
t_0
(if (<= B 2.6e-231)
(/ (* 180.0 (atan 0.0)) PI)
(if (<= B 8.2e-118)
t_0
(if (<= B 3.8e-75)
(/ (* 180.0 (atan (/ (* 0.5 B) A))) PI)
(* (atan (- -1.0 (/ A B))) (/ 180.0 PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((((C - A) / B) + 1.0)) / ((double) M_PI));
double tmp;
if (B <= 8.6e-244) {
tmp = t_0;
} else if (B <= 2.6e-231) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else if (B <= 8.2e-118) {
tmp = t_0;
} else if (B <= 3.8e-75) {
tmp = (180.0 * atan(((0.5 * B) / A))) / ((double) M_PI);
} else {
tmp = atan((-1.0 - (A / B))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan((((C - A) / B) + 1.0)) / Math.PI);
double tmp;
if (B <= 8.6e-244) {
tmp = t_0;
} else if (B <= 2.6e-231) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else if (B <= 8.2e-118) {
tmp = t_0;
} else if (B <= 3.8e-75) {
tmp = (180.0 * Math.atan(((0.5 * B) / A))) / Math.PI;
} else {
tmp = Math.atan((-1.0 - (A / B))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((((C - A) / B) + 1.0)) / math.pi) tmp = 0 if B <= 8.6e-244: tmp = t_0 elif B <= 2.6e-231: tmp = (180.0 * math.atan(0.0)) / math.pi elif B <= 8.2e-118: tmp = t_0 elif B <= 3.8e-75: tmp = (180.0 * math.atan(((0.5 * B) / A))) / math.pi else: tmp = math.atan((-1.0 - (A / B))) * (180.0 / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) / B) + 1.0)) / pi)) tmp = 0.0 if (B <= 8.6e-244) tmp = t_0; elseif (B <= 2.6e-231) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); elseif (B <= 8.2e-118) tmp = t_0; elseif (B <= 3.8e-75) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * B) / A))) / pi); else tmp = Float64(atan(Float64(-1.0 - Float64(A / B))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan((((C - A) / B) + 1.0)) / pi); tmp = 0.0; if (B <= 8.6e-244) tmp = t_0; elseif (B <= 2.6e-231) tmp = (180.0 * atan(0.0)) / pi; elseif (B <= 8.2e-118) tmp = t_0; elseif (B <= 3.8e-75) tmp = (180.0 * atan(((0.5 * B) / A))) / pi; else tmp = atan((-1.0 - (A / B))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, 8.6e-244], t$95$0, If[LessEqual[B, 2.6e-231], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 8.2e-118], t$95$0, If[LessEqual[B, 3.8e-75], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B} + 1\right)}{\pi}\\
\mathbf{if}\;B \leq 8.6 \cdot 10^{-244}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 2.6 \cdot 10^{-231}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{elif}\;B \leq 8.2 \cdot 10^{-118}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 3.8 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(-1 - \frac{A}{B}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if B < 8.59999999999999973e-244 or 2.60000000000000003e-231 < B < 8.2000000000000006e-118Initial program 56.8%
Taylor expanded in B around -inf 62.0%
associate--l+62.0%
div-sub64.8%
Simplified64.8%
if 8.59999999999999973e-244 < B < 2.60000000000000003e-231Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 8.2000000000000006e-118 < B < 3.79999999999999994e-75Initial program 19.4%
associate-*r/19.4%
associate-*l/19.4%
*-un-lft-identity19.4%
unpow219.4%
unpow219.4%
hypot-define60.8%
Applied egg-rr60.8%
Taylor expanded in A around -inf 60.0%
associate-*r/60.0%
Simplified60.0%
if 3.79999999999999994e-75 < B Initial program 55.1%
associate-*r/55.1%
associate-*l/55.1%
*-un-lft-identity55.1%
unpow255.1%
unpow255.1%
hypot-define80.2%
Applied egg-rr80.2%
Taylor expanded in B around inf 77.7%
+-commutative77.7%
associate--r+77.7%
div-sub77.7%
sub-neg77.7%
metadata-eval77.7%
Simplified77.7%
Taylor expanded in C around 0 69.5%
distribute-lft-in69.5%
metadata-eval69.5%
mul-1-neg69.5%
unsub-neg69.5%
Simplified69.5%
Taylor expanded in A around 0 69.5%
associate-*r/69.5%
*-commutative69.5%
+-commutative69.5%
distribute-neg-in69.5%
neg-mul-169.5%
sub-neg69.5%
sub-neg69.5%
metadata-eval69.5%
+-commutative69.5%
neg-mul-169.5%
sub-neg69.5%
associate-/l*69.5%
Simplified69.5%
Final simplification66.9%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (atan (/ (* 0.5 B) A))))
(if (<= B -1.6e-236)
(* 180.0 (/ (atan (/ (- B A) B)) PI))
(if (<= B -1.25e-256)
(/ (* 180.0 t_0) PI)
(if (<= B 8e-285)
(* 180.0 (/ (atan (/ A (- B))) PI))
(if (<= B 7.2e-74)
(* 180.0 (/ t_0 PI))
(* (atan (- -1.0 (/ A B))) (/ 180.0 PI))))))))
double code(double A, double B, double C) {
double t_0 = atan(((0.5 * B) / A));
double tmp;
if (B <= -1.6e-236) {
tmp = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
} else if (B <= -1.25e-256) {
tmp = (180.0 * t_0) / ((double) M_PI);
} else if (B <= 8e-285) {
tmp = 180.0 * (atan((A / -B)) / ((double) M_PI));
} else if (B <= 7.2e-74) {
tmp = 180.0 * (t_0 / ((double) M_PI));
} else {
tmp = atan((-1.0 - (A / B))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = Math.atan(((0.5 * B) / A));
double tmp;
if (B <= -1.6e-236) {
tmp = 180.0 * (Math.atan(((B - A) / B)) / Math.PI);
} else if (B <= -1.25e-256) {
tmp = (180.0 * t_0) / Math.PI;
} else if (B <= 8e-285) {
tmp = 180.0 * (Math.atan((A / -B)) / Math.PI);
} else if (B <= 7.2e-74) {
tmp = 180.0 * (t_0 / Math.PI);
} else {
tmp = Math.atan((-1.0 - (A / B))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = math.atan(((0.5 * B) / A)) tmp = 0 if B <= -1.6e-236: tmp = 180.0 * (math.atan(((B - A) / B)) / math.pi) elif B <= -1.25e-256: tmp = (180.0 * t_0) / math.pi elif B <= 8e-285: tmp = 180.0 * (math.atan((A / -B)) / math.pi) elif B <= 7.2e-74: tmp = 180.0 * (t_0 / math.pi) else: tmp = math.atan((-1.0 - (A / B))) * (180.0 / math.pi) return tmp
function code(A, B, C) t_0 = atan(Float64(Float64(0.5 * B) / A)) tmp = 0.0 if (B <= -1.6e-236) tmp = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi)); elseif (B <= -1.25e-256) tmp = Float64(Float64(180.0 * t_0) / pi); elseif (B <= 8e-285) tmp = Float64(180.0 * Float64(atan(Float64(A / Float64(-B))) / pi)); elseif (B <= 7.2e-74) tmp = Float64(180.0 * Float64(t_0 / pi)); else tmp = Float64(atan(Float64(-1.0 - Float64(A / B))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = atan(((0.5 * B) / A)); tmp = 0.0; if (B <= -1.6e-236) tmp = 180.0 * (atan(((B - A) / B)) / pi); elseif (B <= -1.25e-256) tmp = (180.0 * t_0) / pi; elseif (B <= 8e-285) tmp = 180.0 * (atan((A / -B)) / pi); elseif (B <= 7.2e-74) tmp = 180.0 * (t_0 / pi); else tmp = atan((-1.0 - (A / B))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[B, -1.6e-236], N[(180.0 * N[(N[ArcTan[N[(N[(B - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.25e-256], N[(N[(180.0 * t$95$0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 8e-285], N[(180.0 * N[(N[ArcTan[N[(A / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 7.2e-74], N[(180.0 * N[(t$95$0 / Pi), $MachinePrecision]), $MachinePrecision], N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)\\
\mathbf{if}\;B \leq -1.6 \cdot 10^{-236}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq -1.25 \cdot 10^{-256}:\\
\;\;\;\;\frac{180 \cdot t\_0}{\pi}\\
\mathbf{elif}\;B \leq 8 \cdot 10^{-285}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{-B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 7.2 \cdot 10^{-74}:\\
\;\;\;\;180 \cdot \frac{t\_0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(-1 - \frac{A}{B}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if B < -1.6e-236Initial program 53.0%
Taylor expanded in B around -inf 69.6%
neg-mul-169.6%
Simplified69.6%
Taylor expanded in C around 0 60.6%
if -1.6e-236 < B < -1.25e-256Initial program 48.7%
associate-*r/48.7%
associate-*l/48.7%
*-un-lft-identity48.7%
unpow248.7%
unpow248.7%
hypot-define81.0%
Applied egg-rr81.0%
Taylor expanded in A around -inf 82.2%
associate-*r/82.2%
Simplified82.2%
if -1.25e-256 < B < 8.00000000000000059e-285Initial program 75.2%
Taylor expanded in B around inf 64.2%
Taylor expanded in A around inf 59.0%
associate-*r/59.0%
mul-1-neg59.0%
Simplified59.0%
if 8.00000000000000059e-285 < B < 7.2000000000000005e-74Initial program 45.6%
Taylor expanded in A around -inf 44.7%
associate-*r/44.7%
Simplified44.7%
if 7.2000000000000005e-74 < B Initial program 55.1%
associate-*r/55.1%
associate-*l/55.1%
*-un-lft-identity55.1%
unpow255.1%
unpow255.1%
hypot-define80.2%
Applied egg-rr80.2%
Taylor expanded in B around inf 77.7%
+-commutative77.7%
associate--r+77.7%
div-sub77.7%
sub-neg77.7%
metadata-eval77.7%
Simplified77.7%
Taylor expanded in C around 0 69.5%
distribute-lft-in69.5%
metadata-eval69.5%
mul-1-neg69.5%
unsub-neg69.5%
Simplified69.5%
Taylor expanded in A around 0 69.5%
associate-*r/69.5%
*-commutative69.5%
+-commutative69.5%
distribute-neg-in69.5%
neg-mul-169.5%
sub-neg69.5%
sub-neg69.5%
metadata-eval69.5%
+-commutative69.5%
neg-mul-169.5%
sub-neg69.5%
associate-/l*69.5%
Simplified69.5%
Final simplification61.7%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- B A) B)) PI))))
(if (<= C -7.4e-95)
(* 180.0 (/ (atan (/ (- C B) B)) PI))
(if (<= C 2.2e-229)
t_0
(if (<= C 1.2e-47)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= C 1.75e-7) t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
double tmp;
if (C <= -7.4e-95) {
tmp = 180.0 * (atan(((C - B) / B)) / ((double) M_PI));
} else if (C <= 2.2e-229) {
tmp = t_0;
} else if (C <= 1.2e-47) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (C <= 1.75e-7) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
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 <= -7.4e-95) {
tmp = 180.0 * (Math.atan(((C - B) / B)) / Math.PI);
} else if (C <= 2.2e-229) {
tmp = t_0;
} else if (C <= 1.2e-47) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (C <= 1.75e-7) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((B - A) / B)) / math.pi) tmp = 0 if C <= -7.4e-95: tmp = 180.0 * (math.atan(((C - B) / B)) / math.pi) elif C <= 2.2e-229: tmp = t_0 elif C <= 1.2e-47: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif C <= 1.75e-7: tmp = t_0 else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi)) tmp = 0.0 if (C <= -7.4e-95) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - B) / B)) / pi)); elseif (C <= 2.2e-229) tmp = t_0; elseif (C <= 1.2e-47) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (C <= 1.75e-7) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((B - A) / B)) / pi); tmp = 0.0; if (C <= -7.4e-95) tmp = 180.0 * (atan(((C - B) / B)) / pi); elseif (C <= 2.2e-229) tmp = t_0; elseif (C <= 1.2e-47) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (C <= 1.75e-7) tmp = t_0; else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
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, -7.4e-95], N[(180.0 * N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.2e-229], t$95$0, If[LessEqual[C, 1.2e-47], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 1.75e-7], t$95$0, N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\
\mathbf{if}\;C \leq -7.4 \cdot 10^{-95}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - B}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.2 \cdot 10^{-229}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;C \leq 1.2 \cdot 10^{-47}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;C \leq 1.75 \cdot 10^{-7}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -7.39999999999999989e-95Initial program 70.1%
Taylor expanded in B around inf 72.7%
Taylor expanded in A around 0 70.1%
if -7.39999999999999989e-95 < C < 2.1999999999999999e-229 or 1.2e-47 < C < 1.74999999999999992e-7Initial program 62.2%
Taylor expanded in B around -inf 60.2%
neg-mul-160.2%
Simplified60.2%
Taylor expanded in C around 0 58.9%
if 2.1999999999999999e-229 < C < 1.2e-47Initial program 53.5%
Taylor expanded in A around -inf 45.0%
associate-*r/45.0%
Simplified45.0%
if 1.74999999999999992e-7 < C Initial program 21.2%
Taylor expanded in C around inf 67.2%
Taylor expanded in A around inf 67.2%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- B A) B)) PI))))
(if (<= C -1.05e-72)
(* 180.0 (/ (atan (/ (+ B C) B)) PI))
(if (<= C 2.4e-229)
t_0
(if (<= C 1.45e-47)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= C 6.2e-8) t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((B - A) / B)) / ((double) M_PI));
double tmp;
if (C <= -1.05e-72) {
tmp = 180.0 * (atan(((B + C) / B)) / ((double) M_PI));
} else if (C <= 2.4e-229) {
tmp = t_0;
} else if (C <= 1.45e-47) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (C <= 6.2e-8) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
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 <= -1.05e-72) {
tmp = 180.0 * (Math.atan(((B + C) / B)) / Math.PI);
} else if (C <= 2.4e-229) {
tmp = t_0;
} else if (C <= 1.45e-47) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (C <= 6.2e-8) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((B - A) / B)) / math.pi) tmp = 0 if C <= -1.05e-72: tmp = 180.0 * (math.atan(((B + C) / B)) / math.pi) elif C <= 2.4e-229: tmp = t_0 elif C <= 1.45e-47: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif C <= 6.2e-8: tmp = t_0 else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(B - A) / B)) / pi)) tmp = 0.0 if (C <= -1.05e-72) tmp = Float64(180.0 * Float64(atan(Float64(Float64(B + C) / B)) / pi)); elseif (C <= 2.4e-229) tmp = t_0; elseif (C <= 1.45e-47) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (C <= 6.2e-8) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((B - A) / B)) / pi); tmp = 0.0; if (C <= -1.05e-72) tmp = 180.0 * (atan(((B + C) / B)) / pi); elseif (C <= 2.4e-229) tmp = t_0; elseif (C <= 1.45e-47) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (C <= 6.2e-8) tmp = t_0; else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
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, -1.05e-72], N[(180.0 * N[(N[ArcTan[N[(N[(B + C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.4e-229], t$95$0, If[LessEqual[C, 1.45e-47], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6.2e-8], t$95$0, N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{B - A}{B}\right)}{\pi}\\
\mathbf{if}\;C \leq -1.05 \cdot 10^{-72}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B + C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.4 \cdot 10^{-229}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;C \leq 1.45 \cdot 10^{-47}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;C \leq 6.2 \cdot 10^{-8}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -1.05e-72Initial program 68.6%
Taylor expanded in B around -inf 66.9%
neg-mul-166.9%
Simplified66.9%
Taylor expanded in A around 0 64.5%
if -1.05e-72 < C < 2.4e-229 or 1.45e-47 < C < 6.2e-8Initial program 64.1%
Taylor expanded in B around -inf 59.4%
neg-mul-159.4%
Simplified59.4%
Taylor expanded in C around 0 58.2%
if 2.4e-229 < C < 1.45e-47Initial program 53.5%
Taylor expanded in A around -inf 45.0%
associate-*r/45.0%
Simplified45.0%
if 6.2e-8 < C Initial program 21.2%
Taylor expanded in C around inf 67.2%
Taylor expanded in A around inf 67.2%
(FPCore (A B C)
:precision binary64
(if (<= B 8.6e-244)
(* 180.0 (/ (atan (* (/ 1.0 B) (+ B (- C A)))) PI))
(if (<= B 2.55e-231)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan (+ (/ (- C A) B) -1.0)) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= 8.6e-244) {
tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / ((double) M_PI));
} else if (B <= 2.55e-231) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 8.6e-244) {
tmp = 180.0 * (Math.atan(((1.0 / B) * (B + (C - A)))) / Math.PI);
} else if (B <= 2.55e-231) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((((C - A) / B) + -1.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 8.6e-244: tmp = 180.0 * (math.atan(((1.0 / B) * (B + (C - A)))) / math.pi) elif B <= 2.55e-231: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan((((C - A) / B) + -1.0)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 8.6e-244) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(B + Float64(C - A)))) / pi)); elseif (B <= 2.55e-231) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) / B) + -1.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 8.6e-244) tmp = 180.0 * (atan(((1.0 / B) * (B + (C - A)))) / pi); elseif (B <= 2.55e-231) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan((((C - A) / B) + -1.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 8.6e-244], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(B + N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.55e-231], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 8.6 \cdot 10^{-244}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(B + \left(C - A\right)\right)\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.55 \cdot 10^{-231}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B} + -1\right)}{\pi}\\
\end{array}
\end{array}
if B < 8.59999999999999973e-244Initial program 56.0%
Taylor expanded in B around -inf 65.9%
neg-mul-165.9%
Simplified65.9%
if 8.59999999999999973e-244 < B < 2.55e-231Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 2.55e-231 < B Initial program 52.7%
Taylor expanded in B around inf 69.2%
Taylor expanded in B around 0 69.2%
associate--r+69.2%
sub-neg69.2%
mul-1-neg69.2%
mul-1-neg69.2%
sub-neg69.2%
div-sub69.3%
sub-neg69.3%
*-inverses69.3%
metadata-eval69.3%
Simplified69.3%
Final simplification68.2%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- C A) B)))
(if (<= B 7.8e-244)
(/ (* 180.0 (atan (+ t_0 1.0))) PI)
(if (<= B 2.55e-231)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan (+ t_0 -1.0)) PI))))))
double code(double A, double B, double C) {
double t_0 = (C - A) / B;
double tmp;
if (B <= 7.8e-244) {
tmp = (180.0 * atan((t_0 + 1.0))) / ((double) M_PI);
} else if (B <= 2.55e-231) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((t_0 + -1.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (C - A) / B;
double tmp;
if (B <= 7.8e-244) {
tmp = (180.0 * Math.atan((t_0 + 1.0))) / Math.PI;
} else if (B <= 2.55e-231) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((t_0 + -1.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (C - A) / B tmp = 0 if B <= 7.8e-244: tmp = (180.0 * math.atan((t_0 + 1.0))) / math.pi elif B <= 2.55e-231: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan((t_0 + -1.0)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(C - A) / B) tmp = 0.0 if (B <= 7.8e-244) tmp = Float64(Float64(180.0 * atan(Float64(t_0 + 1.0))) / pi); elseif (B <= 2.55e-231) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(t_0 + -1.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (C - A) / B; tmp = 0.0; if (B <= 7.8e-244) tmp = (180.0 * atan((t_0 + 1.0))) / pi; elseif (B <= 2.55e-231) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan((t_0 + -1.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, 7.8e-244], N[(N[(180.0 * N[ArcTan[N[(t$95$0 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 2.55e-231], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(t$95$0 + -1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{C - A}{B}\\
\mathbf{if}\;B \leq 7.8 \cdot 10^{-244}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(t\_0 + 1\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.55 \cdot 10^{-231}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(t\_0 + -1\right)}{\pi}\\
\end{array}
\end{array}
if B < 7.7999999999999998e-244Initial program 56.0%
associate-*r/56.0%
associate-*l/56.0%
*-un-lft-identity56.0%
unpow256.0%
unpow256.0%
hypot-define78.7%
Applied egg-rr78.7%
Taylor expanded in B around -inf 64.3%
associate--l+64.3%
div-sub65.9%
Simplified65.9%
if 7.7999999999999998e-244 < B < 2.55e-231Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 2.55e-231 < B Initial program 52.7%
Taylor expanded in B around inf 69.2%
Taylor expanded in B around 0 69.2%
associate--r+69.2%
sub-neg69.2%
mul-1-neg69.2%
mul-1-neg69.2%
sub-neg69.2%
div-sub69.3%
sub-neg69.3%
*-inverses69.3%
metadata-eval69.3%
Simplified69.3%
Final simplification68.2%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- C A) B)))
(if (<= B 7.8e-244)
(* 180.0 (/ (atan (+ t_0 1.0)) PI))
(if (<= B 5e-230)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan (+ t_0 -1.0)) PI))))))
double code(double A, double B, double C) {
double t_0 = (C - A) / B;
double tmp;
if (B <= 7.8e-244) {
tmp = 180.0 * (atan((t_0 + 1.0)) / ((double) M_PI));
} else if (B <= 5e-230) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((t_0 + -1.0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (C - A) / B;
double tmp;
if (B <= 7.8e-244) {
tmp = 180.0 * (Math.atan((t_0 + 1.0)) / Math.PI);
} else if (B <= 5e-230) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((t_0 + -1.0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (C - A) / B tmp = 0 if B <= 7.8e-244: tmp = 180.0 * (math.atan((t_0 + 1.0)) / math.pi) elif B <= 5e-230: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan((t_0 + -1.0)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(C - A) / B) tmp = 0.0 if (B <= 7.8e-244) tmp = Float64(180.0 * Float64(atan(Float64(t_0 + 1.0)) / pi)); elseif (B <= 5e-230) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(t_0 + -1.0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (C - A) / B; tmp = 0.0; if (B <= 7.8e-244) tmp = 180.0 * (atan((t_0 + 1.0)) / pi); elseif (B <= 5e-230) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan((t_0 + -1.0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, 7.8e-244], N[(180.0 * N[(N[ArcTan[N[(t$95$0 + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5e-230], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(t$95$0 + -1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{C - A}{B}\\
\mathbf{if}\;B \leq 7.8 \cdot 10^{-244}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(t\_0 + 1\right)}{\pi}\\
\mathbf{elif}\;B \leq 5 \cdot 10^{-230}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(t\_0 + -1\right)}{\pi}\\
\end{array}
\end{array}
if B < 7.7999999999999998e-244Initial program 56.0%
Taylor expanded in B around -inf 64.3%
associate--l+64.3%
div-sub65.9%
Simplified65.9%
if 7.7999999999999998e-244 < B < 5.00000000000000035e-230Initial program 41.9%
associate-*r/41.9%
associate-*l/41.9%
*-un-lft-identity41.9%
unpow241.9%
unpow241.9%
hypot-define100.0%
Applied egg-rr100.0%
div-sub0.0%
Applied egg-rr0.0%
Taylor expanded in C around inf 60.0%
distribute-lft1-in60.0%
metadata-eval60.0%
associate-*r*60.0%
metadata-eval60.0%
mul0-lft100.0%
Simplified100.0%
if 5.00000000000000035e-230 < B Initial program 52.7%
Taylor expanded in B around inf 69.2%
Taylor expanded in B around 0 69.2%
associate--r+69.2%
sub-neg69.2%
mul-1-neg69.2%
mul-1-neg69.2%
sub-neg69.2%
div-sub69.3%
sub-neg69.3%
*-inverses69.3%
metadata-eval69.3%
Simplified69.3%
Final simplification68.2%
(FPCore (A B C)
:precision binary64
(if (<= B -2.75e-188)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 2.5e-268)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 2.55e-74)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.75e-188) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 2.5e-268) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 2.55e-74) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.75e-188) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 2.5e-268) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 2.55e-74) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.75e-188: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 2.5e-268: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 2.55e-74: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.75e-188) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 2.5e-268) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 2.55e-74) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.75e-188) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 2.5e-268) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 2.55e-74) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.75e-188], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.5e-268], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.55e-74], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.75 \cdot 10^{-188}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 2.5 \cdot 10^{-268}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.55 \cdot 10^{-74}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.7500000000000001e-188Initial program 51.0%
Taylor expanded in B around -inf 48.5%
if -2.7500000000000001e-188 < B < 2.5e-268Initial program 70.6%
Taylor expanded in A around inf 54.8%
if 2.5e-268 < B < 2.5499999999999998e-74Initial program 45.3%
associate-*r/45.3%
associate-*l/45.2%
*-un-lft-identity45.2%
unpow245.2%
unpow245.2%
hypot-define77.0%
Applied egg-rr77.0%
div-sub39.2%
Applied egg-rr39.2%
Taylor expanded in C around inf 15.8%
distribute-lft1-in15.8%
metadata-eval15.8%
associate-*r*15.8%
metadata-eval15.8%
mul0-lft40.4%
Simplified40.4%
if 2.5499999999999998e-74 < B Initial program 55.1%
Taylor expanded in B around inf 58.2%
Final simplification51.6%
(FPCore (A B C)
:precision binary64
(if (<= B -2.75e-188)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 2.4e-279)
(* 180.0 (/ (atan (/ A (- B))) PI))
(if (<= B 3.6e-75)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.75e-188) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 2.4e-279) {
tmp = 180.0 * (atan((A / -B)) / ((double) M_PI));
} else if (B <= 3.6e-75) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.75e-188) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 2.4e-279) {
tmp = 180.0 * (Math.atan((A / -B)) / Math.PI);
} else if (B <= 3.6e-75) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.75e-188: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 2.4e-279: tmp = 180.0 * (math.atan((A / -B)) / math.pi) elif B <= 3.6e-75: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.75e-188) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 2.4e-279) tmp = Float64(180.0 * Float64(atan(Float64(A / Float64(-B))) / pi)); elseif (B <= 3.6e-75) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.75e-188) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 2.4e-279) tmp = 180.0 * (atan((A / -B)) / pi); elseif (B <= 3.6e-75) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.75e-188], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.4e-279], N[(180.0 * N[(N[ArcTan[N[(A / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.6e-75], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.75 \cdot 10^{-188}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 2.4 \cdot 10^{-279}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{-B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.6 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.7500000000000001e-188Initial program 51.0%
Taylor expanded in B around -inf 48.5%
if -2.7500000000000001e-188 < B < 2.3999999999999999e-279Initial program 71.9%
Taylor expanded in B around inf 59.3%
Taylor expanded in A around inf 54.9%
associate-*r/54.9%
mul-1-neg54.9%
Simplified54.9%
if 2.3999999999999999e-279 < B < 3.6e-75Initial program 45.6%
associate-*r/45.6%
associate-*l/45.6%
*-un-lft-identity45.6%
unpow245.6%
unpow245.6%
hypot-define78.2%
Applied egg-rr78.2%
div-sub39.7%
Applied egg-rr39.7%
Taylor expanded in C around inf 15.0%
distribute-lft1-in15.0%
metadata-eval15.0%
associate-*r*15.0%
metadata-eval15.0%
mul0-lft40.9%
Simplified40.9%
if 3.6e-75 < B Initial program 55.1%
Taylor expanded in B around inf 58.2%
Final simplification51.6%
(FPCore (A B C)
:precision binary64
(if (<= B -2.05e-78)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 7.2e-280)
(* 180.0 (/ (atan (/ C B)) PI))
(if (<= B 5.2e-75)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.05e-78) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 7.2e-280) {
tmp = 180.0 * (atan((C / B)) / ((double) M_PI));
} else if (B <= 5.2e-75) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.05e-78) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 7.2e-280) {
tmp = 180.0 * (Math.atan((C / B)) / Math.PI);
} else if (B <= 5.2e-75) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.05e-78: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 7.2e-280: tmp = 180.0 * (math.atan((C / B)) / math.pi) elif B <= 5.2e-75: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.05e-78) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 7.2e-280) tmp = Float64(180.0 * Float64(atan(Float64(C / B)) / pi)); elseif (B <= 5.2e-75) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.05e-78) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 7.2e-280) tmp = 180.0 * (atan((C / B)) / pi); elseif (B <= 5.2e-75) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.05e-78], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 7.2e-280], N[(180.0 * N[(N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5.2e-75], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.05 \cdot 10^{-78}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 7.2 \cdot 10^{-280}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 5.2 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.0499999999999999e-78Initial program 46.4%
Taylor expanded in B around -inf 55.1%
if -2.0499999999999999e-78 < B < 7.19999999999999989e-280Initial program 69.0%
Taylor expanded in B around inf 54.9%
Taylor expanded in C around inf 39.2%
if 7.19999999999999989e-280 < B < 5.2e-75Initial program 45.6%
associate-*r/45.6%
associate-*l/45.6%
*-un-lft-identity45.6%
unpow245.6%
unpow245.6%
hypot-define78.2%
Applied egg-rr78.2%
div-sub39.7%
Applied egg-rr39.7%
Taylor expanded in C around inf 15.0%
distribute-lft1-in15.0%
metadata-eval15.0%
associate-*r*15.0%
metadata-eval15.0%
mul0-lft40.9%
Simplified40.9%
if 5.2e-75 < B Initial program 55.1%
Taylor expanded in B around inf 58.2%
(FPCore (A B C)
:precision binary64
(if (<= B -1.46e-173)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 4.8e-75)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -1.46e-173) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 4.8e-75) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -1.46e-173) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 4.8e-75) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -1.46e-173: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 4.8e-75: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -1.46e-173) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 4.8e-75) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -1.46e-173) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 4.8e-75) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -1.46e-173], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 4.8e-75], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -1.46 \cdot 10^{-173}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 4.8 \cdot 10^{-75}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -1.46e-173Initial program 52.5%
Taylor expanded in B around -inf 50.0%
if -1.46e-173 < B < 4.80000000000000039e-75Initial program 55.0%
associate-*r/55.0%
associate-*l/55.0%
*-un-lft-identity55.0%
unpow255.0%
unpow255.0%
hypot-define79.1%
Applied egg-rr79.1%
div-sub46.5%
Applied egg-rr46.5%
Taylor expanded in C around inf 11.7%
distribute-lft1-in11.7%
metadata-eval11.7%
associate-*r*11.7%
metadata-eval11.7%
mul0-lft35.3%
Simplified35.3%
if 4.80000000000000039e-75 < B Initial program 55.1%
Taylor expanded in B around inf 58.2%
(FPCore (A B C) :precision binary64 (if (<= B -4e-310) (* 180.0 (/ (atan 1.0) PI)) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -4e-310) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -4e-310) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -4e-310: tmp = 180.0 * (math.atan(1.0) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -4e-310) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -4e-310) tmp = 180.0 * (atan(1.0) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -4e-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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -4 \cdot 10^{-310}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -3.999999999999988e-310Initial program 54.3%
Taylor expanded in B around -inf 41.1%
if -3.999999999999988e-310 < B Initial program 54.1%
Taylor expanded in B around inf 42.3%
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan -1.0) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(-1.0) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(-1.0) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(-1.0) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(-1.0) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(-1.0) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} -1}{\pi}
\end{array}
Initial program 54.2%
Taylor expanded in B around inf 23.5%
herbie shell --seed 2024110
(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)))