
(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
(let* ((t_0 (hypot B (- A C))) (t_1 (atan (* 0.5 (/ B A)))))
(if (<= A -1.1e+148)
(* (/ 180.0 PI) t_1)
(if (<= A -1.35e-15)
(* 180.0 (/ (atan (/ (- (- C A) t_0) B)) PI))
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_1) 0.005555555555555556))
(* 180.0 (/ (atan (/ (- C (+ A t_0)) B)) PI)))))))
double code(double A, double B, double C) {
double t_0 = hypot(B, (A - C));
double t_1 = atan((0.5 * (B / A)));
double tmp;
if (A <= -1.1e+148) {
tmp = (180.0 / ((double) M_PI)) * t_1;
} else if (A <= -1.35e-15) {
tmp = 180.0 * (atan((((C - A) - t_0) / B)) / ((double) M_PI));
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_1) * 0.005555555555555556);
} else {
tmp = 180.0 * (atan(((C - (A + t_0)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = Math.hypot(B, (A - C));
double t_1 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -1.1e+148) {
tmp = (180.0 / Math.PI) * t_1;
} else if (A <= -1.35e-15) {
tmp = 180.0 * (Math.atan((((C - A) - t_0) / B)) / Math.PI);
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_1) * 0.005555555555555556);
} else {
tmp = 180.0 * (Math.atan(((C - (A + t_0)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = math.hypot(B, (A - C)) t_1 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -1.1e+148: tmp = (180.0 / math.pi) * t_1 elif A <= -1.35e-15: tmp = 180.0 * (math.atan((((C - A) - t_0) / B)) / math.pi) elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_1) * 0.005555555555555556) else: tmp = 180.0 * (math.atan(((C - (A + t_0)) / B)) / math.pi) return tmp
function code(A, B, C) t_0 = hypot(B, Float64(A - C)) t_1 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -1.1e+148) tmp = Float64(Float64(180.0 / pi) * t_1); elseif (A <= -1.35e-15) tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - t_0) / B)) / pi)); elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_1) * 0.005555555555555556)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + t_0)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = hypot(B, (A - C)); t_1 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -1.1e+148) tmp = (180.0 / pi) * t_1; elseif (A <= -1.35e-15) tmp = 180.0 * (atan((((C - A) - t_0) / B)) / pi); elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_1) * 0.005555555555555556); else tmp = 180.0 * (atan(((C - (A + t_0)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -1.1e+148], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[A, -1.35e-15], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - t$95$0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$1), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + t$95$0), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B, A - C\right)\\
t_1 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -1.1 \cdot 10^{+148}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_1\\
\mathbf{elif}\;A \leq -1.35 \cdot 10^{-15}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - t_0}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_1} \cdot 0.005555555555555556}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + t_0\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.0999999999999999e148Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -1.0999999999999999e148 < A < -1.35000000000000005e-15Initial program 43.9%
associate-*l/43.9%
*-lft-identity43.9%
+-commutative43.9%
unpow243.9%
unpow243.9%
hypot-def71.6%
Simplified71.6%
if -1.35000000000000005e-15 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if -1.75e-100 < A Initial program 69.4%
Simplified89.3%
Final simplification85.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
(if (<= t_0 -5e-67)
(* 180.0 (/ (atan (/ (- (- C A) (hypot B (- A C))) B)) PI))
(if (<= t_0 0.0)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(/ 180.0 (/ PI (atan (/ (- (- C A) (hypot (- A C) B)) B))))))))
double code(double A, double B, double C) {
double t_0 = (1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0))));
double tmp;
if (t_0 <= -5e-67) {
tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / ((double) M_PI));
} else if (t_0 <= 0.0) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else {
tmp = 180.0 / (((double) M_PI) / atan((((C - A) - hypot((A - C), B)) / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0))));
double tmp;
if (t_0 <= -5e-67) {
tmp = 180.0 * (Math.atan((((C - A) - Math.hypot(B, (A - C))) / B)) / Math.PI);
} else if (t_0 <= 0.0) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else {
tmp = 180.0 / (Math.PI / Math.atan((((C - A) - Math.hypot((A - C), B)) / B)));
}
return tmp;
}
def code(A, B, C): t_0 = (1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))) tmp = 0 if t_0 <= -5e-67: tmp = 180.0 * (math.atan((((C - A) - math.hypot(B, (A - C))) / B)) / math.pi) elif t_0 <= 0.0: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) else: tmp = 180.0 / (math.pi / math.atan((((C - A) - math.hypot((A - C), B)) / B))) return tmp
function code(A, B, C) t_0 = Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))) tmp = 0.0 if (t_0 <= -5e-67) tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)) / pi)); elseif (t_0 <= 0.0) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B)))); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))); tmp = 0.0; if (t_0 <= -5e-67) tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / pi); elseif (t_0 <= 0.0) tmp = (180.0 / pi) * atan((0.5 * (B / A))); else tmp = 180.0 / (pi / atan((((C - A) - hypot((A - C), B)) / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -5e-67], 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], If[LessEqual[t$95$0, 0.0], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\\
\mathbf{if}\;t_0 \leq -5 \cdot 10^{-67}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}{\pi}\\
\mathbf{elif}\;t_0 \leq 0:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\right)}}\\
\end{array}
\end{array}
if (*.f64 (/.f64 1 B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) 2) (pow.f64 B 2))))) < -4.9999999999999999e-67Initial program 54.5%
associate-*l/54.5%
*-lft-identity54.5%
+-commutative54.5%
unpow254.5%
unpow254.5%
hypot-def86.5%
Simplified86.5%
if -4.9999999999999999e-67 < (*.f64 (/.f64 1 B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) 2) (pow.f64 B 2))))) < 0.0Initial program 10.9%
associate-*l/10.9%
*-lft-identity10.9%
+-commutative10.9%
unpow210.9%
unpow210.9%
hypot-def10.9%
Simplified10.9%
clear-num10.9%
un-div-inv10.9%
div-inv10.9%
associate--r+4.0%
hypot-udef4.0%
unpow24.0%
unpow24.0%
+-commutative4.0%
associate--l-10.9%
*-commutative10.9%
Applied egg-rr10.9%
Taylor expanded in A around -inf 62.0%
associate-/r/62.1%
Applied egg-rr62.1%
if 0.0 < (*.f64 (/.f64 1 B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) 2) (pow.f64 B 2))))) Initial program 67.6%
associate-*l/67.6%
*-lft-identity67.6%
+-commutative67.6%
unpow267.6%
unpow267.6%
hypot-def90.3%
Simplified90.3%
clear-num90.4%
un-div-inv90.4%
div-inv90.4%
associate--r+85.5%
hypot-udef67.6%
unpow267.6%
unpow267.6%
+-commutative67.6%
associate--l-67.6%
*-commutative67.6%
Applied egg-rr90.4%
Final simplification85.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (atan (* 0.5 (/ B A)))))
(if (<= A -7.2e+147)
(* (/ 180.0 PI) t_0)
(if (<= A -7.2e-16)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_0) 0.005555555555555556))
(* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI)))))))
double code(double A, double B, double C) {
double t_0 = atan((0.5 * (B / A)));
double tmp;
if (A <= -7.2e+147) {
tmp = (180.0 / ((double) M_PI)) * t_0;
} else if (A <= -7.2e-16) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_0) * 0.005555555555555556);
} 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 t_0 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -7.2e+147) {
tmp = (180.0 / Math.PI) * t_0;
} else if (A <= -7.2e-16) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_0) * 0.005555555555555556);
} else {
tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -7.2e+147: tmp = (180.0 / math.pi) * t_0 elif A <= -7.2e-16: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_0) * 0.005555555555555556) else: tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi) return tmp
function code(A, B, C) t_0 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -7.2e+147) tmp = Float64(Float64(180.0 / pi) * t_0); elseif (A <= -7.2e-16) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_0) * 0.005555555555555556)); 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) t_0 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -7.2e+147) tmp = (180.0 / pi) * t_0; elseif (A <= -7.2e-16) tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_0) * 0.005555555555555556); else tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -7.2e+147], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[A, -7.2e-16], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$0), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -7.2 \cdot 10^{+147}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_0\\
\mathbf{elif}\;A \leq -7.2 \cdot 10^{-16}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_0} \cdot 0.005555555555555556}\\
\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 < -7.20000000000000041e147Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -7.20000000000000041e147 < A < -7.19999999999999965e-16Initial program 43.9%
Taylor expanded in A around 0 39.2%
unpow239.2%
unpow239.2%
hypot-def66.9%
Simplified66.9%
if -7.19999999999999965e-16 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if -1.75e-100 < A Initial program 69.4%
Simplified89.3%
Final simplification84.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI)))
(t_1 (atan (* 0.5 (/ B A)))))
(if (<= A -2.4e+151)
(* (/ 180.0 PI) t_1)
(if (<= A -8.5e-15)
t_0
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_1) 0.005555555555555556))
(if (<= A 3.3e-26)
t_0
(* 180.0 (/ (atan (/ (- (- A) (hypot B A)) B)) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
double t_1 = atan((0.5 * (B / A)));
double tmp;
if (A <= -2.4e+151) {
tmp = (180.0 / ((double) M_PI)) * t_1;
} else if (A <= -8.5e-15) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_1) * 0.005555555555555556);
} else if (A <= 3.3e-26) {
tmp = t_0;
} 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 t_0 = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
double t_1 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -2.4e+151) {
tmp = (180.0 / Math.PI) * t_1;
} else if (A <= -8.5e-15) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_1) * 0.005555555555555556);
} else if (A <= 3.3e-26) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(((-A - Math.hypot(B, A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) t_1 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -2.4e+151: tmp = (180.0 / math.pi) * t_1 elif A <= -8.5e-15: tmp = t_0 elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_1) * 0.005555555555555556) elif A <= 3.3e-26: tmp = t_0 else: tmp = 180.0 * (math.atan(((-A - math.hypot(B, A)) / B)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)) t_1 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -2.4e+151) tmp = Float64(Float64(180.0 / pi) * t_1); elseif (A <= -8.5e-15) tmp = t_0; elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_1) * 0.005555555555555556)); elseif (A <= 3.3e-26) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) - hypot(B, A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); t_1 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -2.4e+151) tmp = (180.0 / pi) * t_1; elseif (A <= -8.5e-15) tmp = t_0; elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_1) * 0.005555555555555556); elseif (A <= 3.3e-26) tmp = t_0; else tmp = 180.0 * (atan(((-A - hypot(B, A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -2.4e+151], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[A, -8.5e-15], t$95$0, If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$1), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 3.3e-26], t$95$0, 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}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
t_1 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -2.4 \cdot 10^{+151}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_1\\
\mathbf{elif}\;A \leq -8.5 \cdot 10^{-15}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_1} \cdot 0.005555555555555556}\\
\mathbf{elif}\;A \leq 3.3 \cdot 10^{-26}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(-A\right) - \mathsf{hypot}\left(B, A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -2.4000000000000001e151Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -2.4000000000000001e151 < A < -8.50000000000000007e-15 or -1.75e-100 < A < 3.2999999999999998e-26Initial program 56.1%
Taylor expanded in A around 0 52.7%
unpow252.7%
unpow252.7%
hypot-def78.4%
Simplified78.4%
if -8.50000000000000007e-15 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if 3.2999999999999998e-26 < A Initial program 83.2%
Taylor expanded in C around 0 81.0%
associate-*r/81.0%
mul-1-neg81.0%
+-commutative81.0%
unpow281.0%
unpow281.0%
hypot-def89.7%
Simplified89.7%
Final simplification81.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI)))
(t_1 (atan (* 0.5 (/ B A)))))
(if (<= A -3.8e+146)
(* (/ 180.0 PI) t_1)
(if (<= A -6.8e-16)
t_0
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_1) 0.005555555555555556))
(if (<= A 2.75e-25)
t_0
(/ 180.0 (/ PI (atan (/ (- (- A) (hypot A B)) B))))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
double t_1 = atan((0.5 * (B / A)));
double tmp;
if (A <= -3.8e+146) {
tmp = (180.0 / ((double) M_PI)) * t_1;
} else if (A <= -6.8e-16) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_1) * 0.005555555555555556);
} else if (A <= 2.75e-25) {
tmp = t_0;
} else {
tmp = 180.0 / (((double) M_PI) / atan(((-A - hypot(A, B)) / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
double t_1 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -3.8e+146) {
tmp = (180.0 / Math.PI) * t_1;
} else if (A <= -6.8e-16) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_1) * 0.005555555555555556);
} else if (A <= 2.75e-25) {
tmp = t_0;
} else {
tmp = 180.0 / (Math.PI / Math.atan(((-A - Math.hypot(A, B)) / B)));
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) t_1 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -3.8e+146: tmp = (180.0 / math.pi) * t_1 elif A <= -6.8e-16: tmp = t_0 elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_1) * 0.005555555555555556) elif A <= 2.75e-25: tmp = t_0 else: tmp = 180.0 / (math.pi / math.atan(((-A - math.hypot(A, B)) / B))) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)) t_1 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -3.8e+146) tmp = Float64(Float64(180.0 / pi) * t_1); elseif (A <= -6.8e-16) tmp = t_0; elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_1) * 0.005555555555555556)); elseif (A <= 2.75e-25) tmp = t_0; else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(-A) - hypot(A, B)) / B)))); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); t_1 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -3.8e+146) tmp = (180.0 / pi) * t_1; elseif (A <= -6.8e-16) tmp = t_0; elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_1) * 0.005555555555555556); elseif (A <= 2.75e-25) tmp = t_0; else tmp = 180.0 / (pi / atan(((-A - hypot(A, B)) / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -3.8e+146], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[A, -6.8e-16], t$95$0, If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$1), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 2.75e-25], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(N[((-A) - N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
t_1 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -3.8 \cdot 10^{+146}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_1\\
\mathbf{elif}\;A \leq -6.8 \cdot 10^{-16}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_1} \cdot 0.005555555555555556}\\
\mathbf{elif}\;A \leq 2.75 \cdot 10^{-25}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(-A\right) - \mathsf{hypot}\left(A, B\right)}{B}\right)}}\\
\end{array}
\end{array}
if A < -3.79999999999999979e146Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -3.79999999999999979e146 < A < -6.8e-16 or -1.75e-100 < A < 2.75000000000000002e-25Initial program 56.1%
Taylor expanded in A around 0 52.7%
unpow252.7%
unpow252.7%
hypot-def78.4%
Simplified78.4%
if -6.8e-16 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if 2.75000000000000002e-25 < A Initial program 83.2%
associate-*l/83.2%
*-lft-identity83.2%
+-commutative83.2%
unpow283.2%
unpow283.2%
hypot-def96.2%
Simplified96.2%
clear-num96.2%
un-div-inv96.2%
div-inv96.2%
associate--r+96.2%
hypot-udef83.3%
unpow283.3%
unpow283.3%
+-commutative83.3%
associate--l-83.3%
*-commutative83.3%
Applied egg-rr96.2%
Taylor expanded in C around 0 81.0%
mul-1-neg81.0%
unpow281.0%
unpow281.0%
hypot-def89.7%
Simplified89.7%
Final simplification81.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI)))
(t_1 (atan (* 0.5 (/ B A)))))
(if (<= A -1.55e+146)
(* (/ 180.0 PI) t_1)
(if (<= A -8.5e-15)
t_0
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_1) 0.005555555555555556))
(if (<= A 5.9e-41)
t_0
(* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
double t_1 = atan((0.5 * (B / A)));
double tmp;
if (A <= -1.55e+146) {
tmp = (180.0 / ((double) M_PI)) * t_1;
} else if (A <= -8.5e-15) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_1) * 0.005555555555555556);
} else if (A <= 5.9e-41) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(((C - (B + A)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
double t_1 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -1.55e+146) {
tmp = (180.0 / Math.PI) * t_1;
} else if (A <= -8.5e-15) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_1) * 0.005555555555555556);
} else if (A <= 5.9e-41) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) t_1 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -1.55e+146: tmp = (180.0 / math.pi) * t_1 elif A <= -8.5e-15: tmp = t_0 elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_1) * 0.005555555555555556) elif A <= 5.9e-41: tmp = t_0 else: tmp = 180.0 * (math.atan(((C - (B + A)) / B)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)) t_1 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -1.55e+146) tmp = Float64(Float64(180.0 / pi) * t_1); elseif (A <= -8.5e-15) tmp = t_0; elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_1) * 0.005555555555555556)); elseif (A <= 5.9e-41) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); t_1 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -1.55e+146) tmp = (180.0 / pi) * t_1; elseif (A <= -8.5e-15) tmp = t_0; elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_1) * 0.005555555555555556); elseif (A <= 5.9e-41) tmp = t_0; else tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -1.55e+146], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[A, -8.5e-15], t$95$0, If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$1), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 5.9e-41], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
t_1 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -1.55 \cdot 10^{+146}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_1\\
\mathbf{elif}\;A \leq -8.5 \cdot 10^{-15}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_1} \cdot 0.005555555555555556}\\
\mathbf{elif}\;A \leq 5.9 \cdot 10^{-41}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.5500000000000001e146Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -1.5500000000000001e146 < A < -8.50000000000000007e-15 or -1.75e-100 < A < 5.8999999999999997e-41Initial program 55.7%
Taylor expanded in A around 0 52.3%
unpow252.3%
unpow252.3%
hypot-def77.9%
Simplified77.9%
if -8.50000000000000007e-15 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if 5.8999999999999997e-41 < A Initial program 82.8%
Simplified96.3%
Taylor expanded in B around inf 87.7%
+-commutative87.7%
Simplified87.7%
Final simplification81.1%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI)))
(t_1 (atan (* 0.5 (/ B A)))))
(if (<= A -1.5e+146)
(* (/ 180.0 PI) t_1)
(if (<= A -6.8e-16)
t_0
(if (<= A -1.75e-100)
(/ 1.0 (* (/ PI t_1) 0.005555555555555556))
(if (<= A 8.6e-28)
t_0
(/ (* -180.0 (atan (/ (+ A (hypot A B)) B))) PI)))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
double t_1 = atan((0.5 * (B / A)));
double tmp;
if (A <= -1.5e+146) {
tmp = (180.0 / ((double) M_PI)) * t_1;
} else if (A <= -6.8e-16) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((((double) M_PI) / t_1) * 0.005555555555555556);
} else if (A <= 8.6e-28) {
tmp = t_0;
} else {
tmp = (-180.0 * atan(((A + hypot(A, B)) / B))) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
double t_1 = Math.atan((0.5 * (B / A)));
double tmp;
if (A <= -1.5e+146) {
tmp = (180.0 / Math.PI) * t_1;
} else if (A <= -6.8e-16) {
tmp = t_0;
} else if (A <= -1.75e-100) {
tmp = 1.0 / ((Math.PI / t_1) * 0.005555555555555556);
} else if (A <= 8.6e-28) {
tmp = t_0;
} else {
tmp = (-180.0 * Math.atan(((A + Math.hypot(A, B)) / B))) / Math.PI;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) t_1 = math.atan((0.5 * (B / A))) tmp = 0 if A <= -1.5e+146: tmp = (180.0 / math.pi) * t_1 elif A <= -6.8e-16: tmp = t_0 elif A <= -1.75e-100: tmp = 1.0 / ((math.pi / t_1) * 0.005555555555555556) elif A <= 8.6e-28: tmp = t_0 else: tmp = (-180.0 * math.atan(((A + math.hypot(A, B)) / B))) / math.pi return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)) t_1 = atan(Float64(0.5 * Float64(B / A))) tmp = 0.0 if (A <= -1.5e+146) tmp = Float64(Float64(180.0 / pi) * t_1); elseif (A <= -6.8e-16) tmp = t_0; elseif (A <= -1.75e-100) tmp = Float64(1.0 / Float64(Float64(pi / t_1) * 0.005555555555555556)); elseif (A <= 8.6e-28) tmp = t_0; else tmp = Float64(Float64(-180.0 * atan(Float64(Float64(A + hypot(A, B)) / B))) / pi); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); t_1 = atan((0.5 * (B / A))); tmp = 0.0; if (A <= -1.5e+146) tmp = (180.0 / pi) * t_1; elseif (A <= -6.8e-16) tmp = t_0; elseif (A <= -1.75e-100) tmp = 1.0 / ((pi / t_1) * 0.005555555555555556); elseif (A <= 8.6e-28) tmp = t_0; else tmp = (-180.0 * atan(((A + hypot(A, B)) / B))) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[A, -1.5e+146], N[(N[(180.0 / Pi), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[A, -6.8e-16], t$95$0, If[LessEqual[A, -1.75e-100], N[(1.0 / N[(N[(Pi / t$95$1), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 8.6e-28], t$95$0, N[(N[(-180.0 * N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
t_1 := \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{if}\;A \leq -1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{180}{\pi} \cdot t_1\\
\mathbf{elif}\;A \leq -6.8 \cdot 10^{-16}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -1.75 \cdot 10^{-100}:\\
\;\;\;\;\frac{1}{\frac{\pi}{t_1} \cdot 0.005555555555555556}\\
\mathbf{elif}\;A \leq 8.6 \cdot 10^{-28}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{-180 \cdot \tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.50000000000000001e146Initial program 9.0%
associate-*l/9.0%
*-lft-identity9.0%
+-commutative9.0%
unpow29.0%
unpow29.0%
hypot-def55.0%
Simplified55.0%
clear-num55.0%
un-div-inv55.0%
div-inv55.0%
associate--r+18.0%
hypot-udef8.9%
unpow28.9%
unpow28.9%
+-commutative8.9%
associate--l-9.0%
*-commutative9.0%
Applied egg-rr55.0%
Taylor expanded in A around -inf 87.3%
associate-/r/87.4%
Applied egg-rr87.4%
if -1.50000000000000001e146 < A < -6.8e-16 or -1.75e-100 < A < 8.6e-28Initial program 56.1%
Taylor expanded in A around 0 52.7%
unpow252.7%
unpow252.7%
hypot-def78.4%
Simplified78.4%
if -6.8e-16 < A < -1.75e-100Initial program 13.5%
associate-*l/13.5%
*-lft-identity13.5%
+-commutative13.5%
unpow213.5%
unpow213.5%
hypot-def23.9%
Simplified23.9%
clear-num23.9%
un-div-inv23.9%
div-inv23.9%
associate--r+23.1%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.5%
*-commutative13.5%
Applied egg-rr23.9%
Taylor expanded in A around -inf 61.1%
clear-num61.1%
inv-pow61.1%
Applied egg-rr61.1%
unpow-161.1%
div-inv61.4%
metadata-eval61.4%
Applied egg-rr61.4%
if 8.6e-28 < A Initial program 83.2%
associate-*l/83.2%
*-lft-identity83.2%
+-commutative83.2%
unpow283.2%
unpow283.2%
hypot-def96.2%
Simplified96.2%
clear-num96.2%
un-div-inv96.2%
div-inv96.2%
associate--r+96.2%
hypot-udef83.3%
unpow283.3%
unpow283.3%
+-commutative83.3%
associate--l-83.3%
*-commutative83.3%
Applied egg-rr96.2%
Taylor expanded in C around 0 81.0%
mul-1-neg81.0%
unpow281.0%
unpow281.0%
hypot-def89.7%
Simplified89.7%
expm1-log1p-u50.0%
expm1-udef50.0%
associate-/r/50.0%
distribute-frac-neg50.0%
atan-neg50.0%
Applied egg-rr50.0%
expm1-def50.0%
expm1-log1p89.7%
associate-*l/89.7%
neg-mul-189.7%
associate-*r*89.7%
metadata-eval89.7%
Simplified89.7%
Final simplification81.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* (/ A B) -2.0)) PI)))
(t_1 (* 180.0 (/ (atan 1.0) PI))))
(if (<= B -2.5e+94)
t_1
(if (<= B -1.2e-113)
t_0
(if (<= B -1.8e-192)
t_1
(if (<= B -1.9e-256)
(* 180.0 (/ (atan (/ 0.0 B)) PI))
(if (<= B 8.5e-86) t_0 (* 180.0 (/ (atan -1.0) PI)))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
double t_1 = 180.0 * (atan(1.0) / ((double) M_PI));
double tmp;
if (B <= -2.5e+94) {
tmp = t_1;
} else if (B <= -1.2e-113) {
tmp = t_0;
} else if (B <= -1.8e-192) {
tmp = t_1;
} else if (B <= -1.9e-256) {
tmp = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
} else if (B <= 8.5e-86) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
double t_1 = 180.0 * (Math.atan(1.0) / Math.PI);
double tmp;
if (B <= -2.5e+94) {
tmp = t_1;
} else if (B <= -1.2e-113) {
tmp = t_0;
} else if (B <= -1.8e-192) {
tmp = t_1;
} else if (B <= -1.9e-256) {
tmp = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
} else if (B <= 8.5e-86) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) t_1 = 180.0 * (math.atan(1.0) / math.pi) tmp = 0 if B <= -2.5e+94: tmp = t_1 elif B <= -1.2e-113: tmp = t_0 elif B <= -1.8e-192: tmp = t_1 elif B <= -1.9e-256: tmp = 180.0 * (math.atan((0.0 / B)) / math.pi) elif B <= 8.5e-86: tmp = t_0 else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)) t_1 = Float64(180.0 * Float64(atan(1.0) / pi)) tmp = 0.0 if (B <= -2.5e+94) tmp = t_1; elseif (B <= -1.2e-113) tmp = t_0; elseif (B <= -1.8e-192) tmp = t_1; elseif (B <= -1.9e-256) tmp = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi)); elseif (B <= 8.5e-86) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((A / B) * -2.0)) / pi); t_1 = 180.0 * (atan(1.0) / pi); tmp = 0.0; if (B <= -2.5e+94) tmp = t_1; elseif (B <= -1.2e-113) tmp = t_0; elseif (B <= -1.8e-192) tmp = t_1; elseif (B <= -1.9e-256) tmp = 180.0 * (atan((0.0 / B)) / pi); elseif (B <= 8.5e-86) tmp = t_0; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -2.5e+94], t$95$1, If[LessEqual[B, -1.2e-113], t$95$0, If[LessEqual[B, -1.8e-192], t$95$1, If[LessEqual[B, -1.9e-256], N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 8.5e-86], t$95$0, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
t_1 := 180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{if}\;B \leq -2.5 \cdot 10^{+94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;B \leq -1.2 \cdot 10^{-113}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;B \leq -1.8 \cdot 10^{-192}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;B \leq -1.9 \cdot 10^{-256}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 8.5 \cdot 10^{-86}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.50000000000000005e94 or -1.20000000000000006e-113 < B < -1.7999999999999999e-192Initial program 51.0%
Taylor expanded in B around -inf 54.7%
if -2.50000000000000005e94 < B < -1.20000000000000006e-113 or -1.89999999999999988e-256 < B < 8.499999999999999e-86Initial program 62.9%
Taylor expanded in A around inf 38.8%
if -1.7999999999999999e-192 < B < -1.89999999999999988e-256Initial program 59.9%
Taylor expanded in C around inf 37.6%
associate-*r/37.6%
distribute-rgt1-in37.6%
metadata-eval37.6%
mul0-lft37.6%
metadata-eval37.6%
Simplified37.6%
if 8.499999999999999e-86 < B Initial program 45.5%
Taylor expanded in B around inf 61.5%
Final simplification48.8%
(FPCore (A B C)
:precision binary64
(if (<= B -8e-128)
(/ (* 180.0 (atan (/ (- (+ B C) A) B))) PI)
(if (<= B -2.1e-148)
(* 180.0 (/ (atan (* (/ 1.0 B) (* 0.5 (* B (/ B A))))) PI))
(if (<= B -2e-302)
(* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))
(* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -8e-128) {
tmp = (180.0 * atan((((B + C) - A) / B))) / ((double) M_PI);
} else if (B <= -2.1e-148) {
tmp = 180.0 * (atan(((1.0 / B) * (0.5 * (B * (B / A))))) / ((double) M_PI));
} else if (B <= -2e-302) {
tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - (B + A)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -8e-128) {
tmp = (180.0 * Math.atan((((B + C) - A) / B))) / Math.PI;
} else if (B <= -2.1e-148) {
tmp = 180.0 * (Math.atan(((1.0 / B) * (0.5 * (B * (B / A))))) / Math.PI);
} else if (B <= -2e-302) {
tmp = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -8e-128: tmp = (180.0 * math.atan((((B + C) - A) / B))) / math.pi elif B <= -2.1e-148: tmp = 180.0 * (math.atan(((1.0 / B) * (0.5 * (B * (B / A))))) / math.pi) elif B <= -2e-302: tmp = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) else: tmp = 180.0 * (math.atan(((C - (B + A)) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -8e-128) tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(B + C) - A) / B))) / pi); elseif (B <= -2.1e-148) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(0.5 * Float64(B * Float64(B / A))))) / pi)); elseif (B <= -2e-302) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -8e-128) tmp = (180.0 * atan((((B + C) - A) / B))) / pi; elseif (B <= -2.1e-148) tmp = 180.0 * (atan(((1.0 / B) * (0.5 * (B * (B / A))))) / pi); elseif (B <= -2e-302) tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); else tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -8e-128], N[(N[(180.0 * N[ArcTan[N[(N[(N[(B + C), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -2.1e-148], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(0.5 * N[(B * N[(B / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2e-302], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -8 \cdot 10^{-128}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(B + C\right) - A}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq -2.1 \cdot 10^{-148}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(0.5 \cdot \left(B \cdot \frac{B}{A}\right)\right)\right)}{\pi}\\
\mathbf{elif}\;B \leq -2 \cdot 10^{-302}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -8.00000000000000043e-128Initial program 62.8%
associate-*l/62.8%
*-lft-identity62.8%
+-commutative62.8%
unpow262.8%
unpow262.8%
hypot-def84.6%
Simplified84.6%
*-commutative84.6%
associate-*l/84.6%
hypot-udef62.8%
unpow262.8%
unpow262.8%
+-commutative62.8%
unpow262.8%
unpow262.8%
hypot-def84.6%
Applied egg-rr84.6%
Taylor expanded in B around -inf 81.3%
if -8.00000000000000043e-128 < B < -2.1e-148Initial program 14.4%
Taylor expanded in A around -inf 57.4%
unpow257.4%
*-un-lft-identity57.4%
times-frac57.9%
Applied egg-rr57.9%
if -2.1e-148 < B < -1.9999999999999999e-302Initial program 67.8%
Taylor expanded in B around -inf 62.4%
associate--l+62.4%
div-sub64.9%
Simplified64.9%
if -1.9999999999999999e-302 < B Initial program 48.4%
Simplified69.9%
Taylor expanded in B around inf 65.1%
+-commutative65.1%
Simplified65.1%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ 180.0 (/ PI (atan (/ (- A) B)))))
(t_1 (* 180.0 (/ (atan 1.0) PI))))
(if (<= B -2.5e+94)
t_1
(if (<= B -2.25e-116)
t_0
(if (<= B -8.2e-189)
t_1
(if (<= B -2.25e-256)
(* 180.0 (/ (atan (/ 0.0 B)) PI))
(if (<= B 1.26e-85) t_0 (* 180.0 (/ (atan -1.0) PI)))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 / (((double) M_PI) / atan((-A / B)));
double t_1 = 180.0 * (atan(1.0) / ((double) M_PI));
double tmp;
if (B <= -2.5e+94) {
tmp = t_1;
} else if (B <= -2.25e-116) {
tmp = t_0;
} else if (B <= -8.2e-189) {
tmp = t_1;
} else if (B <= -2.25e-256) {
tmp = 180.0 * (atan((0.0 / B)) / ((double) M_PI));
} else if (B <= 1.26e-85) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 / (Math.PI / Math.atan((-A / B)));
double t_1 = 180.0 * (Math.atan(1.0) / Math.PI);
double tmp;
if (B <= -2.5e+94) {
tmp = t_1;
} else if (B <= -2.25e-116) {
tmp = t_0;
} else if (B <= -8.2e-189) {
tmp = t_1;
} else if (B <= -2.25e-256) {
tmp = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
} else if (B <= 1.26e-85) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 / (math.pi / math.atan((-A / B))) t_1 = 180.0 * (math.atan(1.0) / math.pi) tmp = 0 if B <= -2.5e+94: tmp = t_1 elif B <= -2.25e-116: tmp = t_0 elif B <= -8.2e-189: tmp = t_1 elif B <= -2.25e-256: tmp = 180.0 * (math.atan((0.0 / B)) / math.pi) elif B <= 1.26e-85: tmp = t_0 else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 / Float64(pi / atan(Float64(Float64(-A) / B)))) t_1 = Float64(180.0 * Float64(atan(1.0) / pi)) tmp = 0.0 if (B <= -2.5e+94) tmp = t_1; elseif (B <= -2.25e-116) tmp = t_0; elseif (B <= -8.2e-189) tmp = t_1; elseif (B <= -2.25e-256) tmp = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi)); elseif (B <= 1.26e-85) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 / (pi / atan((-A / B))); t_1 = 180.0 * (atan(1.0) / pi); tmp = 0.0; if (B <= -2.5e+94) tmp = t_1; elseif (B <= -2.25e-116) tmp = t_0; elseif (B <= -8.2e-189) tmp = t_1; elseif (B <= -2.25e-256) tmp = 180.0 * (atan((0.0 / B)) / pi); elseif (B <= 1.26e-85) tmp = t_0; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 / N[(Pi / N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -2.5e+94], t$95$1, If[LessEqual[B, -2.25e-116], t$95$0, If[LessEqual[B, -8.2e-189], t$95$1, If[LessEqual[B, -2.25e-256], N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.26e-85], t$95$0, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{-A}{B}\right)}}\\
t_1 := 180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{if}\;B \leq -2.5 \cdot 10^{+94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;B \leq -2.25 \cdot 10^{-116}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;B \leq -8.2 \cdot 10^{-189}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;B \leq -2.25 \cdot 10^{-256}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.26 \cdot 10^{-85}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.50000000000000005e94 or -2.25000000000000006e-116 < B < -8.2000000000000006e-189Initial program 51.0%
Taylor expanded in B around -inf 54.7%
if -2.50000000000000005e94 < B < -2.25000000000000006e-116 or -2.2500000000000001e-256 < B < 1.26e-85Initial program 62.9%
associate-*l/62.9%
*-lft-identity62.9%
+-commutative62.9%
unpow262.9%
unpow262.9%
hypot-def76.8%
Simplified76.8%
clear-num76.7%
un-div-inv76.7%
div-inv76.7%
associate--r+67.5%
hypot-udef61.8%
unpow261.8%
unpow261.8%
+-commutative61.8%
associate--l-62.9%
*-commutative62.9%
Applied egg-rr76.7%
Taylor expanded in C around 0 49.0%
mul-1-neg49.0%
unpow249.0%
unpow249.0%
hypot-def59.5%
Simplified59.5%
Taylor expanded in A around 0 41.0%
Taylor expanded in A around inf 38.8%
associate-*r/38.8%
mul-1-neg38.8%
Simplified38.8%
if -8.2000000000000006e-189 < B < -2.2500000000000001e-256Initial program 59.9%
Taylor expanded in C around inf 37.6%
associate-*r/37.6%
distribute-rgt1-in37.6%
metadata-eval37.6%
mul0-lft37.6%
metadata-eval37.6%
Simplified37.6%
if 1.26e-85 < B Initial program 45.5%
Taylor expanded in B around inf 61.5%
Final simplification48.7%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* 2.0 (/ C B))) PI))))
(if (<= B -0.0275)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -4.7e-256)
t_0
(if (<= B 1.32e-249)
(/ 180.0 (/ PI (atan (/ (- A) B))))
(if (<= B 2.05e-91) t_0 (* 180.0 (/ (atan -1.0) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((2.0 * (C / B))) / ((double) M_PI));
double tmp;
if (B <= -0.0275) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -4.7e-256) {
tmp = t_0;
} else if (B <= 1.32e-249) {
tmp = 180.0 / (((double) M_PI) / atan((-A / B)));
} else if (B <= 2.05e-91) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan((2.0 * (C / B))) / Math.PI);
double tmp;
if (B <= -0.0275) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -4.7e-256) {
tmp = t_0;
} else if (B <= 1.32e-249) {
tmp = 180.0 / (Math.PI / Math.atan((-A / B)));
} else if (B <= 2.05e-91) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((2.0 * (C / B))) / math.pi) tmp = 0 if B <= -0.0275: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -4.7e-256: tmp = t_0 elif B <= 1.32e-249: tmp = 180.0 / (math.pi / math.atan((-A / B))) elif B <= 2.05e-91: tmp = t_0 else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(2.0 * Float64(C / B))) / pi)) tmp = 0.0 if (B <= -0.0275) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -4.7e-256) tmp = t_0; elseif (B <= 1.32e-249) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(-A) / B)))); elseif (B <= 2.05e-91) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan((2.0 * (C / B))) / pi); tmp = 0.0; if (B <= -0.0275) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -4.7e-256) tmp = t_0; elseif (B <= 1.32e-249) tmp = 180.0 / (pi / atan((-A / B))); elseif (B <= 2.05e-91) tmp = t_0; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(2.0 * N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -0.0275], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -4.7e-256], t$95$0, If[LessEqual[B, 1.32e-249], N[(180.0 / N[(Pi / N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.05e-91], t$95$0, N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(2 \cdot \frac{C}{B}\right)}{\pi}\\
\mathbf{if}\;B \leq -0.0275:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -4.7 \cdot 10^{-256}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;B \leq 1.32 \cdot 10^{-249}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{-A}{B}\right)}}\\
\mathbf{elif}\;B \leq 2.05 \cdot 10^{-91}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -0.0275000000000000001Initial program 56.3%
Taylor expanded in B around -inf 58.1%
if -0.0275000000000000001 < B < -4.69999999999999982e-256 or 1.32e-249 < B < 2.05000000000000012e-91Initial program 57.4%
Taylor expanded in C around -inf 37.2%
if -4.69999999999999982e-256 < B < 1.32e-249Initial program 65.7%
associate-*l/65.7%
*-lft-identity65.7%
+-commutative65.7%
unpow265.7%
unpow265.7%
hypot-def86.6%
Simplified86.6%
clear-num86.6%
un-div-inv86.6%
div-inv86.6%
associate--r+65.5%
hypot-udef61.9%
unpow261.9%
unpow261.9%
+-commutative61.9%
associate--l-65.7%
*-commutative65.7%
Applied egg-rr86.6%
Taylor expanded in C around 0 58.8%
mul-1-neg58.8%
unpow258.8%
unpow258.8%
hypot-def76.2%
Simplified76.2%
Taylor expanded in A around 0 54.8%
Taylor expanded in A around inf 54.8%
associate-*r/54.8%
mul-1-neg54.8%
Simplified54.8%
if 2.05000000000000012e-91 < B Initial program 46.3%
Taylor expanded in B around inf 60.9%
Final simplification50.6%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (+ (/ C B) 1.0)) PI)))
(t_1 (* 180.0 (/ (atan (/ 0.5 (/ A B))) PI))))
(if (<= A -1.9e+57)
t_1
(if (<= A -4500000000000.0)
t_0
(if (<= A -6.2e-101)
t_1
(if (<= A 2.15e-155)
t_0
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C / B) + 1.0)) / ((double) M_PI));
double t_1 = 180.0 * (atan((0.5 / (A / B))) / ((double) M_PI));
double tmp;
if (A <= -1.9e+57) {
tmp = t_1;
} else if (A <= -4500000000000.0) {
tmp = t_0;
} else if (A <= -6.2e-101) {
tmp = t_1;
} else if (A <= 2.15e-155) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C / B) + 1.0)) / Math.PI);
double t_1 = 180.0 * (Math.atan((0.5 / (A / B))) / Math.PI);
double tmp;
if (A <= -1.9e+57) {
tmp = t_1;
} else if (A <= -4500000000000.0) {
tmp = t_0;
} else if (A <= -6.2e-101) {
tmp = t_1;
} else if (A <= 2.15e-155) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C / B) + 1.0)) / math.pi) t_1 = 180.0 * (math.atan((0.5 / (A / B))) / math.pi) tmp = 0 if A <= -1.9e+57: tmp = t_1 elif A <= -4500000000000.0: tmp = t_0 elif A <= -6.2e-101: tmp = t_1 elif A <= 2.15e-155: tmp = t_0 else: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + 1.0)) / pi)) t_1 = Float64(180.0 * Float64(atan(Float64(0.5 / Float64(A / B))) / pi)) tmp = 0.0 if (A <= -1.9e+57) tmp = t_1; elseif (A <= -4500000000000.0) tmp = t_0; elseif (A <= -6.2e-101) tmp = t_1; elseif (A <= 2.15e-155) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C / B) + 1.0)) / pi); t_1 = 180.0 * (atan((0.5 / (A / B))) / pi); tmp = 0.0; if (A <= -1.9e+57) tmp = t_1; elseif (A <= -4500000000000.0) tmp = t_0; elseif (A <= -6.2e-101) tmp = t_1; elseif (A <= 2.15e-155) tmp = t_0; else tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[N[(0.5 / N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -1.9e+57], t$95$1, If[LessEqual[A, -4500000000000.0], t$95$0, If[LessEqual[A, -6.2e-101], t$95$1, If[LessEqual[A, 2.15e-155], t$95$0, N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + 1\right)}{\pi}\\
t_1 := 180 \cdot \frac{\tan^{-1} \left(\frac{0.5}{\frac{A}{B}}\right)}{\pi}\\
\mathbf{if}\;A \leq -1.9 \cdot 10^{+57}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;A \leq -4500000000000:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -6.2 \cdot 10^{-101}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;A \leq 2.15 \cdot 10^{-155}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.8999999999999999e57 or -4.5e12 < A < -6.19999999999999946e-101Initial program 18.5%
associate-*l/18.5%
*-lft-identity18.5%
+-commutative18.5%
unpow218.5%
unpow218.5%
hypot-def52.4%
Simplified52.4%
clear-num52.4%
un-div-inv52.4%
div-inv52.4%
associate--r+30.7%
hypot-udef15.3%
unpow215.3%
unpow215.3%
+-commutative15.3%
associate--l-18.5%
*-commutative18.5%
Applied egg-rr52.4%
Taylor expanded in A around -inf 69.6%
Taylor expanded in B around 0 69.0%
*-lft-identity69.0%
*-lft-identity69.0%
associate-*r/69.0%
associate-/l*69.7%
Simplified69.7%
if -1.8999999999999999e57 < A < -4.5e12 or -6.19999999999999946e-101 < A < 2.15000000000000004e-155Initial program 57.0%
Taylor expanded in B around -inf 56.2%
associate--l+56.2%
div-sub56.2%
Simplified56.2%
Taylor expanded in C around inf 54.5%
if 2.15000000000000004e-155 < A Initial program 79.9%
associate-*l/79.9%
*-lft-identity79.9%
+-commutative79.9%
unpow279.9%
unpow279.9%
hypot-def94.9%
Simplified94.9%
clear-num94.9%
un-div-inv94.9%
div-inv94.9%
associate--r+94.9%
hypot-udef79.9%
unpow279.9%
unpow279.9%
+-commutative79.9%
associate--l-79.9%
*-commutative79.9%
Applied egg-rr94.9%
Taylor expanded in C around 0 76.1%
mul-1-neg76.1%
unpow276.1%
unpow276.1%
hypot-def84.7%
Simplified84.7%
Taylor expanded in A around 0 77.2%
Taylor expanded in A around 0 77.2%
neg-mul-177.2%
distribute-neg-frac77.2%
+-commutative77.2%
distribute-neg-in77.2%
mul-1-neg77.2%
sub-neg77.2%
sub-neg77.2%
mul-1-neg77.2%
distribute-neg-in77.2%
+-commutative77.2%
distribute-neg-in77.2%
mul-1-neg77.2%
sub-neg77.2%
Simplified77.2%
Final simplification66.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (+ (/ C B) 1.0)) PI))))
(if (<= A -3.7e+58)
(* 180.0 (/ (atan (/ 0.5 (/ A B))) PI))
(if (<= A -3800000.0)
t_0
(if (<= A -2.7e-101)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(if (<= A 1.25e-155)
t_0
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((C / B) + 1.0)) / ((double) M_PI));
double tmp;
if (A <= -3.7e+58) {
tmp = 180.0 * (atan((0.5 / (A / B))) / ((double) M_PI));
} else if (A <= -3800000.0) {
tmp = t_0;
} else if (A <= -2.7e-101) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else if (A <= 1.25e-155) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((C / B) + 1.0)) / Math.PI);
double tmp;
if (A <= -3.7e+58) {
tmp = 180.0 * (Math.atan((0.5 / (A / B))) / Math.PI);
} else if (A <= -3800000.0) {
tmp = t_0;
} else if (A <= -2.7e-101) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else if (A <= 1.25e-155) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((C / B) + 1.0)) / math.pi) tmp = 0 if A <= -3.7e+58: tmp = 180.0 * (math.atan((0.5 / (A / B))) / math.pi) elif A <= -3800000.0: tmp = t_0 elif A <= -2.7e-101: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) elif A <= 1.25e-155: tmp = t_0 else: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + 1.0)) / pi)) tmp = 0.0 if (A <= -3.7e+58) tmp = Float64(180.0 * Float64(atan(Float64(0.5 / Float64(A / B))) / pi)); elseif (A <= -3800000.0) tmp = t_0; elseif (A <= -2.7e-101) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); elseif (A <= 1.25e-155) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((C / B) + 1.0)) / pi); tmp = 0.0; if (A <= -3.7e+58) tmp = 180.0 * (atan((0.5 / (A / B))) / pi); elseif (A <= -3800000.0) tmp = t_0; elseif (A <= -2.7e-101) tmp = (180.0 / pi) * atan((0.5 * (B / A))); elseif (A <= 1.25e-155) tmp = t_0; else tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -3.7e+58], N[(180.0 * N[(N[ArcTan[N[(0.5 / N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -3800000.0], t$95$0, If[LessEqual[A, -2.7e-101], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.25e-155], t$95$0, N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + 1\right)}{\pi}\\
\mathbf{if}\;A \leq -3.7 \cdot 10^{+58}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5}{\frac{A}{B}}\right)}{\pi}\\
\mathbf{elif}\;A \leq -3800000:\\
\;\;\;\;t_0\\
\mathbf{elif}\;A \leq -2.7 \cdot 10^{-101}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{elif}\;A \leq 1.25 \cdot 10^{-155}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.7000000000000002e58Initial program 20.2%
associate-*l/20.2%
*-lft-identity20.2%
+-commutative20.2%
unpow220.2%
unpow220.2%
hypot-def60.8%
Simplified60.8%
clear-num60.8%
un-div-inv60.8%
div-inv60.8%
associate--r+32.1%
hypot-udef16.1%
unpow216.1%
unpow216.1%
+-commutative16.1%
associate--l-20.2%
*-commutative20.2%
Applied egg-rr60.8%
Taylor expanded in A around -inf 74.4%
Taylor expanded in B around 0 73.5%
*-lft-identity73.5%
*-lft-identity73.5%
associate-*r/73.5%
associate-/l*74.4%
Simplified74.4%
if -3.7000000000000002e58 < A < -3.8e6 or -2.7000000000000002e-101 < A < 1.25e-155Initial program 57.0%
Taylor expanded in B around -inf 56.2%
associate--l+56.2%
div-sub56.2%
Simplified56.2%
Taylor expanded in C around inf 54.5%
if -3.8e6 < A < -2.7000000000000002e-101Initial program 13.4%
associate-*l/13.4%
*-lft-identity13.4%
+-commutative13.4%
unpow213.4%
unpow213.4%
hypot-def27.4%
Simplified27.4%
clear-num27.4%
un-div-inv27.4%
div-inv27.4%
associate--r+26.7%
hypot-udef12.7%
unpow212.7%
unpow212.7%
+-commutative12.7%
associate--l-13.4%
*-commutative13.4%
Applied egg-rr27.4%
Taylor expanded in A around -inf 55.3%
associate-/r/55.5%
Applied egg-rr55.5%
if 1.25e-155 < A Initial program 79.9%
associate-*l/79.9%
*-lft-identity79.9%
+-commutative79.9%
unpow279.9%
unpow279.9%
hypot-def94.9%
Simplified94.9%
clear-num94.9%
un-div-inv94.9%
div-inv94.9%
associate--r+94.9%
hypot-udef79.9%
unpow279.9%
unpow279.9%
+-commutative79.9%
associate--l-79.9%
*-commutative79.9%
Applied egg-rr94.9%
Taylor expanded in C around 0 76.1%
mul-1-neg76.1%
unpow276.1%
unpow276.1%
hypot-def84.7%
Simplified84.7%
Taylor expanded in A around 0 77.2%
Taylor expanded in A around 0 77.2%
neg-mul-177.2%
distribute-neg-frac77.2%
+-commutative77.2%
distribute-neg-in77.2%
mul-1-neg77.2%
sub-neg77.2%
sub-neg77.2%
mul-1-neg77.2%
distribute-neg-in77.2%
+-commutative77.2%
distribute-neg-in77.2%
mul-1-neg77.2%
sub-neg77.2%
Simplified77.2%
Final simplification66.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))))
(if (<= B -1.15e-127)
t_0
(if (<= B -1.9e-148)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(if (<= B 1.35e-80) t_0 (* 180.0 (/ (atan (- -1.0 (/ A B))) PI)))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
double tmp;
if (B <= -1.15e-127) {
tmp = t_0;
} else if (B <= -1.9e-148) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else if (B <= 1.35e-80) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
double tmp;
if (B <= -1.15e-127) {
tmp = t_0;
} else if (B <= -1.9e-148) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else if (B <= 1.35e-80) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) tmp = 0 if B <= -1.15e-127: tmp = t_0 elif B <= -1.9e-148: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) elif B <= 1.35e-80: tmp = t_0 else: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)) tmp = 0.0 if (B <= -1.15e-127) tmp = t_0; elseif (B <= -1.9e-148) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); elseif (B <= 1.35e-80) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); tmp = 0.0; if (B <= -1.15e-127) tmp = t_0; elseif (B <= -1.9e-148) tmp = (180.0 / pi) * atan((0.5 * (B / A))); elseif (B <= 1.35e-80) tmp = t_0; else tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -1.15e-127], t$95$0, If[LessEqual[B, -1.9e-148], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.35e-80], t$95$0, N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\mathbf{if}\;B \leq -1.15 \cdot 10^{-127}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;B \leq -1.9 \cdot 10^{-148}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{elif}\;B \leq 1.35 \cdot 10^{-80}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -1.15000000000000009e-127 or -1.90000000000000007e-148 < B < 1.3500000000000001e-80Initial program 60.4%
Taylor expanded in B around -inf 65.7%
associate--l+65.7%
div-sub68.0%
Simplified68.0%
if -1.15000000000000009e-127 < B < -1.90000000000000007e-148Initial program 14.4%
associate-*l/14.4%
*-lft-identity14.4%
+-commutative14.4%
unpow214.4%
unpow214.4%
hypot-def36.7%
Simplified36.7%
clear-num36.7%
un-div-inv36.7%
div-inv36.7%
associate--r+26.3%
hypot-udef14.7%
unpow214.7%
unpow214.7%
+-commutative14.7%
associate--l-14.4%
*-commutative14.4%
Applied egg-rr36.7%
Taylor expanded in A around -inf 57.7%
associate-/r/57.7%
Applied egg-rr57.7%
if 1.3500000000000001e-80 < B Initial program 46.1%
associate-*l/46.1%
*-lft-identity46.1%
+-commutative46.1%
unpow246.1%
unpow246.1%
hypot-def76.9%
Simplified76.9%
clear-num76.9%
un-div-inv76.9%
div-inv76.9%
associate--r+76.8%
hypot-udef46.1%
unpow246.1%
unpow246.1%
+-commutative46.1%
associate--l-46.1%
*-commutative46.1%
Applied egg-rr76.9%
Taylor expanded in C around 0 42.2%
mul-1-neg42.2%
unpow242.2%
unpow242.2%
hypot-def71.4%
Simplified71.4%
Taylor expanded in A around 0 70.2%
Taylor expanded in A around 0 70.2%
neg-mul-170.2%
distribute-neg-frac70.2%
+-commutative70.2%
distribute-neg-in70.2%
mul-1-neg70.2%
sub-neg70.2%
sub-neg70.2%
mul-1-neg70.2%
distribute-neg-in70.2%
+-commutative70.2%
distribute-neg-in70.2%
mul-1-neg70.2%
sub-neg70.2%
Simplified70.2%
Final simplification68.2%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))))
(if (<= B -8e-128)
t_0
(if (<= B -2.1e-148)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(if (<= B -2e-302) t_0 (* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI)))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
double tmp;
if (B <= -8e-128) {
tmp = t_0;
} else if (B <= -2.1e-148) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else if (B <= -2e-302) {
tmp = t_0;
} else {
tmp = 180.0 * (atan(((C - (B + A)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
double tmp;
if (B <= -8e-128) {
tmp = t_0;
} else if (B <= -2.1e-148) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else if (B <= -2e-302) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) tmp = 0 if B <= -8e-128: tmp = t_0 elif B <= -2.1e-148: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) elif B <= -2e-302: tmp = t_0 else: tmp = 180.0 * (math.atan(((C - (B + A)) / B)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)) tmp = 0.0 if (B <= -8e-128) tmp = t_0; elseif (B <= -2.1e-148) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); elseif (B <= -2e-302) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); tmp = 0.0; if (B <= -8e-128) tmp = t_0; elseif (B <= -2.1e-148) tmp = (180.0 / pi) * atan((0.5 * (B / A))); elseif (B <= -2e-302) tmp = t_0; else tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -8e-128], t$95$0, If[LessEqual[B, -2.1e-148], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2e-302], t$95$0, N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\mathbf{if}\;B \leq -8 \cdot 10^{-128}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;B \leq -2.1 \cdot 10^{-148}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{elif}\;B \leq -2 \cdot 10^{-302}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -8.00000000000000043e-128 or -2.1e-148 < B < -1.9999999999999999e-302Initial program 64.4%
Taylor expanded in B around -inf 75.5%
associate--l+75.5%
div-sub76.3%
Simplified76.3%
if -8.00000000000000043e-128 < B < -2.1e-148Initial program 14.4%
associate-*l/14.4%
*-lft-identity14.4%
+-commutative14.4%
unpow214.4%
unpow214.4%
hypot-def36.7%
Simplified36.7%
clear-num36.7%
un-div-inv36.7%
div-inv36.7%
associate--r+26.3%
hypot-udef14.7%
unpow214.7%
unpow214.7%
+-commutative14.7%
associate--l-14.4%
*-commutative14.4%
Applied egg-rr36.7%
Taylor expanded in A around -inf 57.7%
associate-/r/57.7%
Applied egg-rr57.7%
if -1.9999999999999999e-302 < B Initial program 48.4%
Simplified69.9%
Taylor expanded in B around inf 65.1%
+-commutative65.1%
Simplified65.1%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(if (<= B -2.2e-125)
(* 180.0 (/ (atan (/ (- C (- A B)) B)) PI))
(if (<= B -9.2e-149)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(if (<= B -5e-182)
(* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))
(* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.2e-125) {
tmp = 180.0 * (atan(((C - (A - B)) / B)) / ((double) M_PI));
} else if (B <= -9.2e-149) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else if (B <= -5e-182) {
tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - (B + A)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.2e-125) {
tmp = 180.0 * (Math.atan(((C - (A - B)) / B)) / Math.PI);
} else if (B <= -9.2e-149) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else if (B <= -5e-182) {
tmp = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.2e-125: tmp = 180.0 * (math.atan(((C - (A - B)) / B)) / math.pi) elif B <= -9.2e-149: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) elif B <= -5e-182: tmp = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) else: tmp = 180.0 * (math.atan(((C - (B + A)) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.2e-125) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A - B)) / B)) / pi)); elseif (B <= -9.2e-149) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); elseif (B <= -5e-182) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.2e-125) tmp = 180.0 * (atan(((C - (A - B)) / B)) / pi); elseif (B <= -9.2e-149) tmp = (180.0 / pi) * atan((0.5 * (B / A))); elseif (B <= -5e-182) tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); else tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.2e-125], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A - B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -9.2e-149], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -5e-182], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.2 \cdot 10^{-125}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A - B\right)}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq -9.2 \cdot 10^{-149}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{elif}\;B \leq -5 \cdot 10^{-182}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -2.19999999999999995e-125Initial program 62.8%
Simplified82.4%
Taylor expanded in B around -inf 81.3%
neg-mul-181.3%
unsub-neg81.3%
Simplified81.3%
if -2.19999999999999995e-125 < B < -9.1999999999999999e-149Initial program 14.4%
associate-*l/14.4%
*-lft-identity14.4%
+-commutative14.4%
unpow214.4%
unpow214.4%
hypot-def36.7%
Simplified36.7%
clear-num36.7%
un-div-inv36.7%
div-inv36.7%
associate--r+26.3%
hypot-udef14.7%
unpow214.7%
unpow214.7%
+-commutative14.7%
associate--l-14.4%
*-commutative14.4%
Applied egg-rr36.7%
Taylor expanded in A around -inf 57.7%
associate-/r/57.7%
Applied egg-rr57.7%
if -9.1999999999999999e-149 < B < -5.00000000000000024e-182Initial program 68.2%
Taylor expanded in B around -inf 78.3%
associate--l+78.3%
div-sub78.3%
Simplified78.3%
if -5.00000000000000024e-182 < B Initial program 52.3%
Simplified70.1%
Taylor expanded in B around inf 64.2%
+-commutative64.2%
Simplified64.2%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(if (<= B -2.5e-127)
(/ (* 180.0 (atan (/ (- (+ B C) A) B))) PI)
(if (<= B -2.1e-148)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(if (<= B -2e-302)
(* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))
(* 180.0 (/ (atan (/ (- C (+ B A)) B)) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.5e-127) {
tmp = (180.0 * atan((((B + C) - A) / B))) / ((double) M_PI);
} else if (B <= -2.1e-148) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else if (B <= -2e-302) {
tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - (B + A)) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.5e-127) {
tmp = (180.0 * Math.atan((((B + C) - A) / B))) / Math.PI;
} else if (B <= -2.1e-148) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else if (B <= -2e-302) {
tmp = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - (B + A)) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.5e-127: tmp = (180.0 * math.atan((((B + C) - A) / B))) / math.pi elif B <= -2.1e-148: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) elif B <= -2e-302: tmp = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) else: tmp = 180.0 * (math.atan(((C - (B + A)) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.5e-127) tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(B + C) - A) / B))) / pi); elseif (B <= -2.1e-148) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); elseif (B <= -2e-302) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.5e-127) tmp = (180.0 * atan((((B + C) - A) / B))) / pi; elseif (B <= -2.1e-148) tmp = (180.0 / pi) * atan((0.5 * (B / A))); elseif (B <= -2e-302) tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); else tmp = 180.0 * (atan(((C - (B + A)) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.5e-127], N[(N[(180.0 * N[ArcTan[N[(N[(N[(B + C), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -2.1e-148], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2e-302], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.5 \cdot 10^{-127}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(B + C\right) - A}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq -2.1 \cdot 10^{-148}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{elif}\;B \leq -2 \cdot 10^{-302}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -2.4999999999999999e-127Initial program 62.8%
associate-*l/62.8%
*-lft-identity62.8%
+-commutative62.8%
unpow262.8%
unpow262.8%
hypot-def84.6%
Simplified84.6%
*-commutative84.6%
associate-*l/84.6%
hypot-udef62.8%
unpow262.8%
unpow262.8%
+-commutative62.8%
unpow262.8%
unpow262.8%
hypot-def84.6%
Applied egg-rr84.6%
Taylor expanded in B around -inf 81.3%
if -2.4999999999999999e-127 < B < -2.1e-148Initial program 14.4%
associate-*l/14.4%
*-lft-identity14.4%
+-commutative14.4%
unpow214.4%
unpow214.4%
hypot-def36.7%
Simplified36.7%
clear-num36.7%
un-div-inv36.7%
div-inv36.7%
associate--r+26.3%
hypot-udef14.7%
unpow214.7%
unpow214.7%
+-commutative14.7%
associate--l-14.4%
*-commutative14.4%
Applied egg-rr36.7%
Taylor expanded in A around -inf 57.7%
associate-/r/57.7%
Applied egg-rr57.7%
if -2.1e-148 < B < -1.9999999999999999e-302Initial program 67.8%
Taylor expanded in B around -inf 62.4%
associate--l+62.4%
div-sub64.9%
Simplified64.9%
if -1.9999999999999999e-302 < B Initial program 48.4%
Simplified69.9%
Taylor expanded in B around inf 65.1%
+-commutative65.1%
Simplified65.1%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(if (<= B -4.7e-256)
(* 180.0 (/ (atan (+ (/ C B) 1.0)) PI))
(if (<= B 1.45e-249)
(/ 180.0 (/ PI (atan (/ (- A) B))))
(if (<= B 1.9e-91)
(* 180.0 (/ (atan (* 2.0 (/ C B))) PI))
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -4.7e-256) {
tmp = 180.0 * (atan(((C / B) + 1.0)) / ((double) M_PI));
} else if (B <= 1.45e-249) {
tmp = 180.0 / (((double) M_PI) / atan((-A / B)));
} else if (B <= 1.9e-91) {
tmp = 180.0 * (atan((2.0 * (C / B))) / ((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 <= -4.7e-256) {
tmp = 180.0 * (Math.atan(((C / B) + 1.0)) / Math.PI);
} else if (B <= 1.45e-249) {
tmp = 180.0 / (Math.PI / Math.atan((-A / B)));
} else if (B <= 1.9e-91) {
tmp = 180.0 * (Math.atan((2.0 * (C / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -4.7e-256: tmp = 180.0 * (math.atan(((C / B) + 1.0)) / math.pi) elif B <= 1.45e-249: tmp = 180.0 / (math.pi / math.atan((-A / B))) elif B <= 1.9e-91: tmp = 180.0 * (math.atan((2.0 * (C / B))) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -4.7e-256) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + 1.0)) / pi)); elseif (B <= 1.45e-249) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(-A) / B)))); elseif (B <= 1.9e-91) tmp = Float64(180.0 * Float64(atan(Float64(2.0 * Float64(C / B))) / 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 <= -4.7e-256) tmp = 180.0 * (atan(((C / B) + 1.0)) / pi); elseif (B <= 1.45e-249) tmp = 180.0 / (pi / atan((-A / B))); elseif (B <= 1.9e-91) tmp = 180.0 * (atan((2.0 * (C / B))) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -4.7e-256], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.45e-249], N[(180.0 / N[(Pi / N[ArcTan[N[((-A) / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.9e-91], N[(180.0 * N[(N[ArcTan[N[(2.0 * N[(C / B), $MachinePrecision]), $MachinePrecision]], $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.7 \cdot 10^{-256}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + 1\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.45 \cdot 10^{-249}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{-A}{B}\right)}}\\
\mathbf{elif}\;B \leq 1.9 \cdot 10^{-91}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(2 \cdot \frac{C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -4.69999999999999982e-256Initial program 60.5%
Taylor expanded in B around -inf 72.8%
associate--l+72.8%
div-sub73.6%
Simplified73.6%
Taylor expanded in C around inf 60.3%
if -4.69999999999999982e-256 < B < 1.45000000000000011e-249Initial program 65.7%
associate-*l/65.7%
*-lft-identity65.7%
+-commutative65.7%
unpow265.7%
unpow265.7%
hypot-def86.6%
Simplified86.6%
clear-num86.6%
un-div-inv86.6%
div-inv86.6%
associate--r+65.5%
hypot-udef61.9%
unpow261.9%
unpow261.9%
+-commutative61.9%
associate--l-65.7%
*-commutative65.7%
Applied egg-rr86.6%
Taylor expanded in C around 0 58.8%
mul-1-neg58.8%
unpow258.8%
unpow258.8%
hypot-def76.2%
Simplified76.2%
Taylor expanded in A around 0 54.8%
Taylor expanded in A around inf 54.8%
associate-*r/54.8%
mul-1-neg54.8%
Simplified54.8%
if 1.45000000000000011e-249 < B < 1.89999999999999989e-91Initial program 46.1%
Taylor expanded in C around -inf 34.5%
if 1.89999999999999989e-91 < B Initial program 46.3%
Taylor expanded in B around inf 60.9%
Final simplification55.9%
(FPCore (A B C)
:precision binary64
(if (<= B -1.26e-42)
(* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
(if (<= B -5e-256)
(* 180.0 (/ (atan (+ (/ C B) 1.0)) PI))
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -1.26e-42) {
tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
} else if (B <= -5e-256) {
tmp = 180.0 * (atan(((C / B) + 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -1.26e-42) {
tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
} else if (B <= -5e-256) {
tmp = 180.0 * (Math.atan(((C / B) + 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -1.26e-42: tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi) elif B <= -5e-256: tmp = 180.0 * (math.atan(((C / B) + 1.0)) / math.pi) else: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -1.26e-42) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi)); elseif (B <= -5e-256) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -1.26e-42) tmp = 180.0 * (atan((1.0 - (A / B))) / pi); elseif (B <= -5e-256) tmp = 180.0 * (atan(((C / B) + 1.0)) / pi); else tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -1.26e-42], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -5e-256], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -1.26 \cdot 10^{-42}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq -5 \cdot 10^{-256}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -1.26e-42Initial program 59.7%
Taylor expanded in B around -inf 81.8%
associate--l+81.8%
div-sub81.8%
Simplified81.8%
Taylor expanded in C around 0 75.6%
if -1.26e-42 < B < -5e-256Initial program 61.7%
Taylor expanded in B around -inf 59.2%
associate--l+59.2%
div-sub61.3%
Simplified61.3%
Taylor expanded in C around inf 51.6%
if -5e-256 < B Initial program 50.2%
associate-*l/50.2%
*-lft-identity50.2%
+-commutative50.2%
unpow250.2%
unpow250.2%
hypot-def76.1%
Simplified76.1%
clear-num76.1%
un-div-inv76.1%
div-inv76.1%
associate--r+69.4%
hypot-udef49.3%
unpow249.3%
unpow249.3%
+-commutative49.3%
associate--l-50.2%
*-commutative50.2%
Applied egg-rr76.1%
Taylor expanded in C around 0 41.4%
mul-1-neg41.4%
unpow241.4%
unpow241.4%
hypot-def63.2%
Simplified63.2%
Taylor expanded in A around 0 55.1%
Taylor expanded in A around 0 55.1%
neg-mul-155.1%
distribute-neg-frac55.1%
+-commutative55.1%
distribute-neg-in55.1%
mul-1-neg55.1%
sub-neg55.1%
sub-neg55.1%
mul-1-neg55.1%
distribute-neg-in55.1%
+-commutative55.1%
distribute-neg-in55.1%
mul-1-neg55.1%
sub-neg55.1%
Simplified55.1%
Final simplification60.3%
(FPCore (A B C)
:precision binary64
(if (<= B -5.6e-190)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 5.3e-76)
(* 180.0 (/ (atan (/ 0.0 B)) PI))
(* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5.6e-190) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 5.3e-76) {
tmp = 180.0 * (atan((0.0 / B)) / ((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 <= -5.6e-190) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 5.3e-76) {
tmp = 180.0 * (Math.atan((0.0 / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5.6e-190: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 5.3e-76: tmp = 180.0 * (math.atan((0.0 / B)) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5.6e-190) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 5.3e-76) tmp = Float64(180.0 * Float64(atan(Float64(0.0 / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5.6e-190) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 5.3e-76) tmp = 180.0 * (atan((0.0 / B)) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5.6e-190], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5.3e-76], N[(180.0 * N[(N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5.6 \cdot 10^{-190}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 5.3 \cdot 10^{-76}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -5.60000000000000011e-190Initial program 59.5%
Taylor expanded in B around -inf 44.8%
if -5.60000000000000011e-190 < B < 5.3e-76Initial program 55.9%
Taylor expanded in C around inf 25.4%
associate-*r/25.4%
distribute-rgt1-in25.4%
metadata-eval25.4%
mul0-lft25.4%
metadata-eval25.4%
Simplified25.4%
if 5.3e-76 < B Initial program 46.8%
Taylor expanded in B around inf 63.3%
Final simplification43.0%
(FPCore (A B C) :precision binary64 (if (<= B -5.5e-256) (* 180.0 (/ (atan (+ (/ C B) 1.0)) PI)) (* 180.0 (/ (atan (- -1.0 (/ A B))) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5.5e-256) {
tmp = 180.0 * (atan(((C / B) + 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -5.5e-256) {
tmp = 180.0 * (Math.atan(((C / B) + 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5.5e-256: tmp = 180.0 * (math.atan(((C / B) + 1.0)) / math.pi) else: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5.5e-256) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5.5e-256) tmp = 180.0 * (atan(((C / B) + 1.0)) / pi); else tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5.5e-256], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5.5 \cdot 10^{-256}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if B < -5.4999999999999998e-256Initial program 60.5%
Taylor expanded in B around -inf 72.8%
associate--l+72.8%
div-sub73.6%
Simplified73.6%
Taylor expanded in C around inf 60.3%
if -5.4999999999999998e-256 < B Initial program 50.2%
associate-*l/50.2%
*-lft-identity50.2%
+-commutative50.2%
unpow250.2%
unpow250.2%
hypot-def76.1%
Simplified76.1%
clear-num76.1%
un-div-inv76.1%
div-inv76.1%
associate--r+69.4%
hypot-udef49.3%
unpow249.3%
unpow249.3%
+-commutative49.3%
associate--l-50.2%
*-commutative50.2%
Applied egg-rr76.1%
Taylor expanded in C around 0 41.4%
mul-1-neg41.4%
unpow241.4%
unpow241.4%
hypot-def63.2%
Simplified63.2%
Taylor expanded in A around 0 55.1%
Taylor expanded in A around 0 55.1%
neg-mul-155.1%
distribute-neg-frac55.1%
+-commutative55.1%
distribute-neg-in55.1%
mul-1-neg55.1%
sub-neg55.1%
sub-neg55.1%
mul-1-neg55.1%
distribute-neg-in55.1%
+-commutative55.1%
distribute-neg-in55.1%
mul-1-neg55.1%
sub-neg55.1%
Simplified55.1%
Final simplification57.6%
(FPCore (A B C) :precision binary64 (if (<= B -1e-309) (* 180.0 (/ (atan 1.0) PI)) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -1e-309) {
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 <= -1e-309) {
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 <= -1e-309: 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 <= -1e-309) 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 <= -1e-309) 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, -1e-309], 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 -1 \cdot 10^{-309}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -1.000000000000002e-309Initial program 61.0%
Taylor expanded in B around -inf 37.8%
if -1.000000000000002e-309 < B Initial program 48.4%
Taylor expanded in B around inf 40.8%
Final simplification39.2%
(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 55.1%
Taylor expanded in B around inf 20.2%
Final simplification20.2%
herbie shell --seed 2023310
(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)))