
(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 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi}
\end{array}
(FPCore (A B C) :precision binary64 (if (<= C 1e+69) (* 180.0 (/ (atan (/ (- (- C A) (hypot B (- A C))) B)) PI)) (* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))
double code(double A, double B, double C) {
double tmp;
if (C <= 1e+69) {
tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / ((double) M_PI));
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 1e+69) {
tmp = 180.0 * (Math.atan((((C - A) - Math.hypot(B, (A - C))) / B)) / Math.PI);
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 1e+69: tmp = 180.0 * (math.atan((((C - A) - math.hypot(B, (A - C))) / B)) / math.pi) else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 1e+69) tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)) / pi)); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 1e+69) tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / pi); else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 1e+69], 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], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 10^{+69}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < 1.0000000000000001e69Initial program 66.0%
associate-*l/66.0%
*-lft-identity66.0%
+-commutative66.0%
unpow266.0%
unpow266.0%
hypot-define85.8%
Simplified85.8%
if 1.0000000000000001e69 < C Initial program 20.1%
associate-*r/20.1%
Applied egg-rr53.8%
div-inv53.8%
Applied egg-rr53.8%
Taylor expanded in C around inf 76.1%
metadata-eval76.1%
cancel-sign-sub-inv76.1%
distribute-rgt1-in76.1%
metadata-eval76.1%
mul0-lft76.1%
div076.1%
metadata-eval76.1%
neg-sub076.1%
distribute-lft-neg-in76.1%
metadata-eval76.1%
Simplified76.1%
Taylor expanded in B around 0 76.0%
associate-*r/76.1%
*-commutative76.1%
associate-/l*76.1%
associate-*r/76.1%
*-commutative76.1%
associate-/l*76.1%
Simplified76.1%
(FPCore (A B C)
:precision binary64
(if (<= A -2.6e+92)
(/ (* 180.0 (atan (/ (* B 0.5) A))) PI)
(if (<= A 7e-67)
(/ (* 180.0 (atan (* (- C (hypot C B)) (/ 1.0 B)))) PI)
(* (/ 180.0 PI) (atan (/ (+ A (hypot A B)) (- B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.6e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else if (A <= 7e-67) {
tmp = (180.0 * atan(((C - hypot(C, B)) * (1.0 / B)))) / ((double) M_PI);
} 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 tmp;
if (A <= -2.6e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else if (A <= 7e-67) {
tmp = (180.0 * Math.atan(((C - Math.hypot(C, B)) * (1.0 / B)))) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan(((A + Math.hypot(A, B)) / -B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.6e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi elif A <= 7e-67: tmp = (180.0 * math.atan(((C - math.hypot(C, B)) * (1.0 / B)))) / math.pi else: tmp = (180.0 / math.pi) * math.atan(((A + math.hypot(A, B)) / -B)) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.6e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); elseif (A <= 7e-67) tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - hypot(C, B)) * Float64(1.0 / B)))) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(A + hypot(A, B)) / Float64(-B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -2.6e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; elseif (A <= 7e-67) tmp = (180.0 * atan(((C - hypot(C, B)) * (1.0 / B)))) / pi; else tmp = (180.0 / pi) * atan(((A + hypot(A, B)) / -B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.6e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 7e-67], N[(N[(180.0 * N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] * N[(1.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -2.6 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 7 \cdot 10^{-67}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\left(C - \mathsf{hypot}\left(C, B\right)\right) \cdot \frac{1}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)\\
\end{array}
\end{array}
if A < -2.5999999999999999e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -2.5999999999999999e92 < A < 7.0000000000000001e-67Initial program 51.4%
associate-*r/51.4%
Applied egg-rr74.1%
Taylor expanded in A around 0 50.1%
+-commutative50.1%
unpow250.1%
unpow250.1%
hypot-define72.8%
Simplified72.8%
div-inv72.8%
Applied egg-rr72.8%
if 7.0000000000000001e-67 < A Initial program 81.5%
Taylor expanded in B around 0 81.5%
Simplified96.0%
Taylor expanded in C around 0 81.5%
mul-1-neg81.5%
unpow281.5%
unpow281.5%
hypot-define93.6%
Simplified93.6%
Final simplification81.1%
(FPCore (A B C)
:precision binary64
(if (<= A -2.7e+92)
(/ (* 180.0 (atan (/ (* B 0.5) A))) PI)
(if (<= A 5e-68)
(/ (* 180.0 (atan (/ (- C (hypot C B)) B))) PI)
(* (/ 180.0 PI) (atan (/ (+ A (hypot A B)) (- B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else if (A <= 5e-68) {
tmp = (180.0 * atan(((C - hypot(C, B)) / B))) / ((double) M_PI);
} 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 tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else if (A <= 5e-68) {
tmp = (180.0 * Math.atan(((C - Math.hypot(C, B)) / B))) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan(((A + Math.hypot(A, B)) / -B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.7e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi elif A <= 5e-68: tmp = (180.0 * math.atan(((C - math.hypot(C, B)) / B))) / math.pi else: tmp = (180.0 / math.pi) * math.atan(((A + math.hypot(A, B)) / -B)) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.7e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); elseif (A <= 5e-68) tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - hypot(C, B)) / B))) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(A + hypot(A, B)) / Float64(-B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -2.7e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; elseif (A <= 5e-68) tmp = (180.0 * atan(((C - hypot(C, B)) / B))) / pi; else tmp = (180.0 / pi) * atan(((A + hypot(A, B)) / -B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.7e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 5e-68], N[(N[(180.0 * N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -2.7 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 5 \cdot 10^{-68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)\\
\end{array}
\end{array}
if A < -2.6999999999999999e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -2.6999999999999999e92 < A < 4.99999999999999971e-68Initial program 51.4%
associate-*r/51.4%
Applied egg-rr74.1%
Taylor expanded in A around 0 50.1%
+-commutative50.1%
unpow250.1%
unpow250.1%
hypot-define72.8%
Simplified72.8%
if 4.99999999999999971e-68 < A Initial program 81.5%
Taylor expanded in B around 0 81.5%
Simplified96.0%
Taylor expanded in C around 0 81.5%
mul-1-neg81.5%
unpow281.5%
unpow281.5%
hypot-define93.6%
Simplified93.6%
Final simplification81.1%
(FPCore (A B C)
:precision binary64
(if (<= A -3.1e+92)
(/ (* 180.0 (atan (/ (* B 0.5) A))) PI)
(if (<= A 7.8e-67)
(/ (* 180.0 (atan (/ (- C (hypot C B)) B))) PI)
(/ (* -180.0 (atan (/ (+ A (hypot A B)) B))) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else if (A <= 7.8e-67) {
tmp = (180.0 * atan(((C - hypot(C, B)) / B))) / ((double) M_PI);
} 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 tmp;
if (A <= -3.1e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else if (A <= 7.8e-67) {
tmp = (180.0 * Math.atan(((C - Math.hypot(C, B)) / B))) / Math.PI;
} else {
tmp = (-180.0 * Math.atan(((A + Math.hypot(A, B)) / B))) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.1e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi elif A <= 7.8e-67: tmp = (180.0 * math.atan(((C - math.hypot(C, B)) / B))) / math.pi else: tmp = (-180.0 * math.atan(((A + math.hypot(A, B)) / B))) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.1e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); elseif (A <= 7.8e-67) tmp = Float64(Float64(180.0 * atan(Float64(Float64(C - hypot(C, B)) / B))) / pi); 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) tmp = 0.0; if (A <= -3.1e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; elseif (A <= 7.8e-67) tmp = (180.0 * atan(((C - hypot(C, B)) / B))) / pi; else tmp = (-180.0 * atan(((A + hypot(A, B)) / B))) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.1e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 7.8e-67], N[(N[(180.0 * N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], 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}
\mathbf{if}\;A \leq -3.1 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 7.8 \cdot 10^{-67}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}{\pi}\\
\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 < -3.1000000000000002e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -3.1000000000000002e92 < A < 7.7999999999999997e-67Initial program 51.4%
associate-*r/51.4%
Applied egg-rr74.1%
Taylor expanded in A around 0 50.1%
+-commutative50.1%
unpow250.1%
unpow250.1%
hypot-define72.8%
Simplified72.8%
if 7.7999999999999997e-67 < A Initial program 81.5%
Taylor expanded in C around 0 81.5%
associate-*r/81.5%
mul-1-neg81.5%
unpow281.5%
unpow281.5%
hypot-define93.6%
Simplified93.6%
associate-*r/93.6%
distribute-frac-neg93.6%
atan-neg93.6%
Applied egg-rr93.6%
distribute-rgt-neg-out93.6%
distribute-lft-neg-in93.6%
metadata-eval93.6%
Simplified93.6%
(FPCore (A B C)
:precision binary64
(if (<= A -2.7e+92)
(/ (* 180.0 (atan (/ (* B 0.5) A))) PI)
(if (<= A 5.2e-68)
(* 180.0 (/ (atan (/ (- C (hypot C B)) B)) PI))
(/ (* -180.0 (atan (/ (+ A (hypot A B)) B))) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else if (A <= 5.2e-68) {
tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / ((double) M_PI));
} 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 tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else if (A <= 5.2e-68) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(C, B)) / B)) / Math.PI);
} else {
tmp = (-180.0 * Math.atan(((A + Math.hypot(A, B)) / B))) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.7e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi elif A <= 5.2e-68: tmp = 180.0 * (math.atan(((C - math.hypot(C, B)) / B)) / math.pi) else: tmp = (-180.0 * math.atan(((A + math.hypot(A, B)) / B))) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.7e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); elseif (A <= 5.2e-68) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(C, B)) / B)) / pi)); 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) tmp = 0.0; if (A <= -2.7e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; elseif (A <= 5.2e-68) tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / pi); else tmp = (-180.0 * atan(((A + hypot(A, B)) / B))) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.7e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 5.2e-68], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], 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}
\mathbf{if}\;A \leq -2.7 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 5.2 \cdot 10^{-68}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}{\pi}\\
\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 < -2.6999999999999999e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -2.6999999999999999e92 < A < 5.1999999999999996e-68Initial program 51.4%
Taylor expanded in A around 0 50.1%
+-commutative50.1%
unpow250.1%
unpow250.1%
hypot-define72.8%
Simplified72.8%
if 5.1999999999999996e-68 < A Initial program 81.5%
Taylor expanded in C around 0 81.5%
associate-*r/81.5%
mul-1-neg81.5%
unpow281.5%
unpow281.5%
hypot-define93.6%
Simplified93.6%
associate-*r/93.6%
distribute-frac-neg93.6%
atan-neg93.6%
Applied egg-rr93.6%
distribute-rgt-neg-out93.6%
distribute-lft-neg-in93.6%
metadata-eval93.6%
Simplified93.6%
(FPCore (A B C)
:precision binary64
(if (<= A -3e+92)
(/ (* 180.0 (atan (/ (* B 0.5) A))) PI)
(if (<= A 6.6e-22)
(* 180.0 (/ (atan (/ (- C (hypot C B)) B)) PI))
(/ (* 180.0 (atan (+ 1.0 (/ (- C A) B)))) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else if (A <= 6.6e-22) {
tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / ((double) M_PI));
} else {
tmp = (180.0 * atan((1.0 + ((C - A) / B)))) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else if (A <= 6.6e-22) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(C, B)) / B)) / Math.PI);
} else {
tmp = (180.0 * Math.atan((1.0 + ((C - A) / B)))) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi elif A <= 6.6e-22: tmp = 180.0 * (math.atan(((C - math.hypot(C, B)) / B)) / math.pi) else: tmp = (180.0 * math.atan((1.0 + ((C - A) / B)))) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); elseif (A <= 6.6e-22) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(C, B)) / B)) / pi)); else tmp = Float64(Float64(180.0 * atan(Float64(1.0 + Float64(Float64(C - A) / B)))) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; elseif (A <= 6.6e-22) tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / pi); else tmp = (180.0 * atan((1.0 + ((C - A) / B)))) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 6.6e-22], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 6.6 \cdot 10^{-22}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.00000000000000013e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -3.00000000000000013e92 < A < 6.6000000000000002e-22Initial program 51.4%
Taylor expanded in A around 0 50.2%
+-commutative50.2%
unpow250.2%
unpow250.2%
hypot-define74.8%
Simplified74.8%
if 6.6000000000000002e-22 < A Initial program 85.4%
associate-*r/85.4%
Applied egg-rr95.4%
Taylor expanded in B around -inf 85.7%
associate--l+85.7%
div-sub89.6%
Simplified89.6%
(FPCore (A B C) :precision binary64 (if (<= A -2.7e+92) (/ (* 180.0 (atan (/ (* B 0.5) A))) PI) (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * atan(((B * 0.5) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -2.7e+92) {
tmp = (180.0 * Math.atan(((B * 0.5) / A))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.7e+92: tmp = (180.0 * math.atan(((B * 0.5) / A))) / math.pi else: tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.7e+92) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B * 0.5) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(A - C)))) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -2.7e+92) tmp = (180.0 * atan(((B * 0.5) / A))) / pi; else tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.7e+92], N[(N[(180.0 * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -2.7 \cdot 10^{+92}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(B, A - C\right)\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -2.6999999999999999e92Initial program 16.9%
associate-*r/16.9%
Applied egg-rr56.9%
Taylor expanded in A around -inf 79.8%
associate-*r/79.8%
*-commutative79.8%
Simplified79.8%
if -2.6999999999999999e92 < A Initial program 63.8%
Simplified83.2%
(FPCore (A B C)
:precision binary64
(if (<= C -1.05e-174)
(/ (* 180.0 (atan (+ 1.0 (/ (- C A) B)))) PI)
(if (<= C 5.3e-219)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 2.9e-78)
(/ (* 180.0 (atan (- 1.0 (/ A B)))) PI)
(* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -1.05e-174) {
tmp = (180.0 * atan((1.0 + ((C - A) / B)))) / ((double) M_PI);
} else if (C <= 5.3e-219) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 2.9e-78) {
tmp = (180.0 * atan((1.0 - (A / B)))) / ((double) M_PI);
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -1.05e-174) {
tmp = (180.0 * Math.atan((1.0 + ((C - A) / B)))) / Math.PI;
} else if (C <= 5.3e-219) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 2.9e-78) {
tmp = (180.0 * Math.atan((1.0 - (A / B)))) / Math.PI;
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -1.05e-174: tmp = (180.0 * math.atan((1.0 + ((C - A) / B)))) / math.pi elif C <= 5.3e-219: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 2.9e-78: tmp = (180.0 * math.atan((1.0 - (A / B)))) / math.pi else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -1.05e-174) tmp = Float64(Float64(180.0 * atan(Float64(1.0 + Float64(Float64(C - A) / B)))) / pi); elseif (C <= 5.3e-219) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 2.9e-78) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - Float64(A / B)))) / pi); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -1.05e-174) tmp = (180.0 * atan((1.0 + ((C - A) / B)))) / pi; elseif (C <= 5.3e-219) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 2.9e-78) tmp = (180.0 * atan((1.0 - (A / B)))) / pi; else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -1.05e-174], N[(N[(180.0 * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 5.3e-219], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.9e-78], N[(N[(180.0 * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.05 \cdot 10^{-174}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 5.3 \cdot 10^{-219}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.9 \cdot 10^{-78}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < -1.05000000000000005e-174Initial program 70.8%
associate-*r/70.8%
Applied egg-rr90.5%
Taylor expanded in B around -inf 68.8%
associate--l+68.8%
div-sub71.0%
Simplified71.0%
if -1.05000000000000005e-174 < C < 5.3000000000000003e-219Initial program 66.7%
Taylor expanded in C around 0 66.9%
associate-*r/66.9%
mul-1-neg66.9%
unpow266.9%
unpow266.9%
hypot-define81.8%
Simplified81.8%
Taylor expanded in A around 0 69.0%
Taylor expanded in A around 0 69.0%
associate-*r/69.0%
neg-mul-169.0%
+-commutative69.0%
distribute-neg-in69.0%
sub-neg69.0%
mul-1-neg69.0%
div-sub69.0%
mul-1-neg69.0%
distribute-frac-neg69.0%
*-inverses69.0%
metadata-eval69.0%
Simplified69.0%
if 5.3000000000000003e-219 < C < 2.9000000000000001e-78Initial program 73.1%
associate-*r/73.0%
Applied egg-rr89.3%
Taylor expanded in B around -inf 76.4%
associate--l+76.4%
div-sub76.4%
Simplified76.4%
Taylor expanded in C around 0 76.4%
if 2.9000000000000001e-78 < C Initial program 24.8%
associate-*r/24.8%
Applied egg-rr57.4%
div-inv57.4%
Applied egg-rr57.4%
Taylor expanded in C around inf 64.3%
metadata-eval64.3%
cancel-sign-sub-inv64.3%
distribute-rgt1-in64.3%
metadata-eval64.3%
mul0-lft64.3%
div064.3%
metadata-eval64.3%
neg-sub064.3%
distribute-lft-neg-in64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in B around 0 64.2%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
Simplified64.3%
(FPCore (A B C)
:precision binary64
(if (<= C -1.88e-174)
(* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI))
(if (<= C 6.4e-219)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 2.6e-81)
(/ (* 180.0 (atan (- 1.0 (/ A B)))) PI)
(* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -1.88e-174) {
tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
} else if (C <= 6.4e-219) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 2.6e-81) {
tmp = (180.0 * atan((1.0 - (A / B)))) / ((double) M_PI);
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -1.88e-174) {
tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
} else if (C <= 6.4e-219) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 2.6e-81) {
tmp = (180.0 * Math.atan((1.0 - (A / B)))) / Math.PI;
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -1.88e-174: tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi) elif C <= 6.4e-219: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 2.6e-81: tmp = (180.0 * math.atan((1.0 - (A / B)))) / math.pi else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -1.88e-174) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi)); elseif (C <= 6.4e-219) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 2.6e-81) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - Float64(A / B)))) / pi); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -1.88e-174) tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi); elseif (C <= 6.4e-219) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 2.6e-81) tmp = (180.0 * atan((1.0 - (A / B)))) / pi; else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -1.88e-174], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6.4e-219], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.6e-81], N[(N[(180.0 * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.88 \cdot 10^{-174}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 6.4 \cdot 10^{-219}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.6 \cdot 10^{-81}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < -1.87999999999999999e-174Initial program 70.8%
Taylor expanded in B around -inf 68.8%
associate--l+68.8%
div-sub71.0%
Simplified71.0%
if -1.87999999999999999e-174 < C < 6.39999999999999995e-219Initial program 66.7%
Taylor expanded in C around 0 66.9%
associate-*r/66.9%
mul-1-neg66.9%
unpow266.9%
unpow266.9%
hypot-define81.8%
Simplified81.8%
Taylor expanded in A around 0 69.0%
Taylor expanded in A around 0 69.0%
associate-*r/69.0%
neg-mul-169.0%
+-commutative69.0%
distribute-neg-in69.0%
sub-neg69.0%
mul-1-neg69.0%
div-sub69.0%
mul-1-neg69.0%
distribute-frac-neg69.0%
*-inverses69.0%
metadata-eval69.0%
Simplified69.0%
if 6.39999999999999995e-219 < C < 2.5999999999999999e-81Initial program 73.1%
associate-*r/73.0%
Applied egg-rr89.3%
Taylor expanded in B around -inf 76.4%
associate--l+76.4%
div-sub76.4%
Simplified76.4%
Taylor expanded in C around 0 76.4%
if 2.5999999999999999e-81 < C Initial program 24.8%
associate-*r/24.8%
Applied egg-rr57.4%
div-inv57.4%
Applied egg-rr57.4%
Taylor expanded in C around inf 64.3%
metadata-eval64.3%
cancel-sign-sub-inv64.3%
distribute-rgt1-in64.3%
metadata-eval64.3%
mul0-lft64.3%
div064.3%
metadata-eval64.3%
neg-sub064.3%
distribute-lft-neg-in64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in B around 0 64.2%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
Simplified64.3%
(FPCore (A B C)
:precision binary64
(if (<= C -5.5e-175)
(/ (* 180.0 (atan (+ 1.0 (/ C B)))) PI)
(if (<= C 1.2e-218)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 3.1e-80)
(/ (* 180.0 (atan (- 1.0 (/ A B)))) PI)
(* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -5.5e-175) {
tmp = (180.0 * atan((1.0 + (C / B)))) / ((double) M_PI);
} else if (C <= 1.2e-218) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 3.1e-80) {
tmp = (180.0 * atan((1.0 - (A / B)))) / ((double) M_PI);
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -5.5e-175) {
tmp = (180.0 * Math.atan((1.0 + (C / B)))) / Math.PI;
} else if (C <= 1.2e-218) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 3.1e-80) {
tmp = (180.0 * Math.atan((1.0 - (A / B)))) / Math.PI;
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -5.5e-175: tmp = (180.0 * math.atan((1.0 + (C / B)))) / math.pi elif C <= 1.2e-218: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 3.1e-80: tmp = (180.0 * math.atan((1.0 - (A / B)))) / math.pi else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -5.5e-175) tmp = Float64(Float64(180.0 * atan(Float64(1.0 + Float64(C / B)))) / pi); elseif (C <= 1.2e-218) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 3.1e-80) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - Float64(A / B)))) / pi); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -5.5e-175) tmp = (180.0 * atan((1.0 + (C / B)))) / pi; elseif (C <= 1.2e-218) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 3.1e-80) tmp = (180.0 * atan((1.0 - (A / B)))) / pi; else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -5.5e-175], N[(N[(180.0 * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 1.2e-218], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 3.1e-80], N[(N[(180.0 * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -5.5 \cdot 10^{-175}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 1.2 \cdot 10^{-218}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 3.1 \cdot 10^{-80}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < -5.50000000000000054e-175Initial program 70.1%
associate-*r/70.1%
Applied egg-rr89.6%
Taylor expanded in A around 0 66.9%
+-commutative66.9%
unpow266.9%
unpow266.9%
hypot-define79.0%
Simplified79.0%
Taylor expanded in B around -inf 66.3%
if -5.50000000000000054e-175 < C < 1.2e-218Initial program 68.3%
Taylor expanded in C around 0 68.5%
associate-*r/68.5%
mul-1-neg68.5%
unpow268.5%
unpow268.5%
hypot-define83.7%
Simplified83.7%
Taylor expanded in A around 0 70.7%
Taylor expanded in A around 0 70.7%
associate-*r/70.7%
neg-mul-170.7%
+-commutative70.7%
distribute-neg-in70.7%
sub-neg70.7%
mul-1-neg70.7%
div-sub70.7%
mul-1-neg70.7%
distribute-frac-neg70.7%
*-inverses70.7%
metadata-eval70.7%
Simplified70.7%
if 1.2e-218 < C < 3.10000000000000016e-80Initial program 73.1%
associate-*r/73.0%
Applied egg-rr89.3%
Taylor expanded in B around -inf 76.4%
associate--l+76.4%
div-sub76.4%
Simplified76.4%
Taylor expanded in C around 0 76.4%
if 3.10000000000000016e-80 < C Initial program 24.8%
associate-*r/24.8%
Applied egg-rr57.4%
div-inv57.4%
Applied egg-rr57.4%
Taylor expanded in C around inf 64.3%
metadata-eval64.3%
cancel-sign-sub-inv64.3%
distribute-rgt1-in64.3%
metadata-eval64.3%
mul0-lft64.3%
div064.3%
metadata-eval64.3%
neg-sub064.3%
distribute-lft-neg-in64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in B around 0 64.2%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
Simplified64.3%
(FPCore (A B C)
:precision binary64
(if (<= C -5.2e-175)
(/ (* 180.0 (atan (+ 1.0 (/ C B)))) PI)
(if (<= C 8e-219)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 2.9e-78)
(* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
(* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -5.2e-175) {
tmp = (180.0 * atan((1.0 + (C / B)))) / ((double) M_PI);
} else if (C <= 8e-219) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 2.9e-78) {
tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -5.2e-175) {
tmp = (180.0 * Math.atan((1.0 + (C / B)))) / Math.PI;
} else if (C <= 8e-219) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 2.9e-78) {
tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -5.2e-175: tmp = (180.0 * math.atan((1.0 + (C / B)))) / math.pi elif C <= 8e-219: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 2.9e-78: tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi) else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -5.2e-175) tmp = Float64(Float64(180.0 * atan(Float64(1.0 + Float64(C / B)))) / pi); elseif (C <= 8e-219) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 2.9e-78) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi)); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -5.2e-175) tmp = (180.0 * atan((1.0 + (C / B)))) / pi; elseif (C <= 8e-219) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 2.9e-78) tmp = 180.0 * (atan((1.0 - (A / B))) / pi); else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -5.2e-175], N[(N[(180.0 * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 8e-219], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.9e-78], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -5.2 \cdot 10^{-175}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 8 \cdot 10^{-219}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.9 \cdot 10^{-78}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < -5.2e-175Initial program 70.1%
associate-*r/70.1%
Applied egg-rr89.6%
Taylor expanded in A around 0 66.9%
+-commutative66.9%
unpow266.9%
unpow266.9%
hypot-define79.0%
Simplified79.0%
Taylor expanded in B around -inf 66.3%
if -5.2e-175 < C < 8.0000000000000003e-219Initial program 68.3%
Taylor expanded in C around 0 68.5%
associate-*r/68.5%
mul-1-neg68.5%
unpow268.5%
unpow268.5%
hypot-define83.7%
Simplified83.7%
Taylor expanded in A around 0 70.7%
Taylor expanded in A around 0 70.7%
associate-*r/70.7%
neg-mul-170.7%
+-commutative70.7%
distribute-neg-in70.7%
sub-neg70.7%
mul-1-neg70.7%
div-sub70.7%
mul-1-neg70.7%
distribute-frac-neg70.7%
*-inverses70.7%
metadata-eval70.7%
Simplified70.7%
if 8.0000000000000003e-219 < C < 2.9000000000000001e-78Initial program 73.1%
Taylor expanded in C around 0 73.2%
associate-*r/73.2%
mul-1-neg73.2%
unpow273.2%
unpow273.2%
hypot-define89.5%
Simplified89.5%
Taylor expanded in B around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
Simplified76.4%
if 2.9000000000000001e-78 < C Initial program 24.8%
associate-*r/24.8%
Applied egg-rr57.4%
div-inv57.4%
Applied egg-rr57.4%
Taylor expanded in C around inf 64.3%
metadata-eval64.3%
cancel-sign-sub-inv64.3%
distribute-rgt1-in64.3%
metadata-eval64.3%
mul0-lft64.3%
div064.3%
metadata-eval64.3%
neg-sub064.3%
distribute-lft-neg-in64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in B around 0 64.2%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
Simplified64.3%
(FPCore (A B C)
:precision binary64
(if (<= C -2.15e+67)
(* 180.0 (/ (atan (/ (* C 2.0) B)) PI))
(if (<= C 9.8e-219)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 2.05e-78)
(* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
(* (atan (* B (/ -0.5 C))) (/ 180.0 PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -2.15e+67) {
tmp = 180.0 * (atan(((C * 2.0) / B)) / ((double) M_PI));
} else if (C <= 9.8e-219) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 2.05e-78) {
tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
} else {
tmp = atan((B * (-0.5 / C))) * (180.0 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -2.15e+67) {
tmp = 180.0 * (Math.atan(((C * 2.0) / B)) / Math.PI);
} else if (C <= 9.8e-219) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 2.05e-78) {
tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
} else {
tmp = Math.atan((B * (-0.5 / C))) * (180.0 / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -2.15e+67: tmp = 180.0 * (math.atan(((C * 2.0) / B)) / math.pi) elif C <= 9.8e-219: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 2.05e-78: tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi) else: tmp = math.atan((B * (-0.5 / C))) * (180.0 / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -2.15e+67) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C * 2.0) / B)) / pi)); elseif (C <= 9.8e-219) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 2.05e-78) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi)); else tmp = Float64(atan(Float64(B * Float64(-0.5 / C))) * Float64(180.0 / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -2.15e+67) tmp = 180.0 * (atan(((C * 2.0) / B)) / pi); elseif (C <= 9.8e-219) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 2.05e-78) tmp = 180.0 * (atan((1.0 - (A / B))) / pi); else tmp = atan((B * (-0.5 / C))) * (180.0 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -2.15e+67], N[(180.0 * N[(N[ArcTan[N[(N[(C * 2.0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 9.8e-219], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 2.05e-78], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -2.15 \cdot 10^{+67}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C \cdot 2}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 9.8 \cdot 10^{-219}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 2.05 \cdot 10^{-78}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(B \cdot \frac{-0.5}{C}\right) \cdot \frac{180}{\pi}\\
\end{array}
\end{array}
if C < -2.1500000000000001e67Initial program 76.7%
Taylor expanded in C around -inf 72.9%
associate-*r/72.9%
*-commutative72.9%
Simplified72.9%
if -2.1500000000000001e67 < C < 9.79999999999999981e-219Initial program 66.1%
Taylor expanded in C around 0 58.6%
associate-*r/58.6%
mul-1-neg58.6%
unpow258.6%
unpow258.6%
hypot-define77.5%
Simplified77.5%
Taylor expanded in A around 0 53.9%
Taylor expanded in A around 0 53.9%
associate-*r/53.9%
neg-mul-153.9%
+-commutative53.9%
distribute-neg-in53.9%
sub-neg53.9%
mul-1-neg53.9%
div-sub53.9%
mul-1-neg53.9%
distribute-frac-neg53.9%
*-inverses53.9%
metadata-eval53.9%
Simplified53.9%
if 9.79999999999999981e-219 < C < 2.0499999999999999e-78Initial program 73.1%
Taylor expanded in C around 0 73.2%
associate-*r/73.2%
mul-1-neg73.2%
unpow273.2%
unpow273.2%
hypot-define89.5%
Simplified89.5%
Taylor expanded in B around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
Simplified76.4%
if 2.0499999999999999e-78 < C Initial program 24.8%
associate-*r/24.8%
Applied egg-rr57.4%
div-inv57.4%
Applied egg-rr57.4%
Taylor expanded in C around inf 64.3%
metadata-eval64.3%
cancel-sign-sub-inv64.3%
distribute-rgt1-in64.3%
metadata-eval64.3%
mul0-lft64.3%
div064.3%
metadata-eval64.3%
neg-sub064.3%
distribute-lft-neg-in64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in B around 0 64.2%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
associate-*r/64.3%
*-commutative64.3%
associate-/l*64.3%
Simplified64.3%
(FPCore (A B C)
:precision binary64
(if (<= C -1.26e+67)
(* 180.0 (/ (atan (/ (* C 2.0) B)) PI))
(if (<= C 4.9e-219)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 3e-80)
(* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -1.26e+67) {
tmp = 180.0 * (atan(((C * 2.0) / B)) / ((double) M_PI));
} else if (C <= 4.9e-219) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 3e-80) {
tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -1.26e+67) {
tmp = 180.0 * (Math.atan(((C * 2.0) / B)) / Math.PI);
} else if (C <= 4.9e-219) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 3e-80) {
tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -1.26e+67: tmp = 180.0 * (math.atan(((C * 2.0) / B)) / math.pi) elif C <= 4.9e-219: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 3e-80: tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -1.26e+67) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C * 2.0) / B)) / pi)); elseif (C <= 4.9e-219) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 3e-80) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -1.26e+67) tmp = 180.0 * (atan(((C * 2.0) / B)) / pi); elseif (C <= 4.9e-219) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 3e-80) tmp = 180.0 * (atan((1.0 - (A / B))) / pi); else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -1.26e+67], N[(180.0 * N[(N[ArcTan[N[(N[(C * 2.0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 4.9e-219], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 3e-80], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.26 \cdot 10^{+67}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C \cdot 2}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 4.9 \cdot 10^{-219}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 3 \cdot 10^{-80}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -1.26e67Initial program 76.7%
Taylor expanded in C around -inf 72.9%
associate-*r/72.9%
*-commutative72.9%
Simplified72.9%
if -1.26e67 < C < 4.8999999999999999e-219Initial program 66.1%
Taylor expanded in C around 0 58.6%
associate-*r/58.6%
mul-1-neg58.6%
unpow258.6%
unpow258.6%
hypot-define77.5%
Simplified77.5%
Taylor expanded in A around 0 53.9%
Taylor expanded in A around 0 53.9%
associate-*r/53.9%
neg-mul-153.9%
+-commutative53.9%
distribute-neg-in53.9%
sub-neg53.9%
mul-1-neg53.9%
div-sub53.9%
mul-1-neg53.9%
distribute-frac-neg53.9%
*-inverses53.9%
metadata-eval53.9%
Simplified53.9%
if 4.8999999999999999e-219 < C < 3.00000000000000007e-80Initial program 73.1%
Taylor expanded in C around 0 73.2%
associate-*r/73.2%
mul-1-neg73.2%
unpow273.2%
unpow273.2%
hypot-define89.5%
Simplified89.5%
Taylor expanded in B around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
Simplified76.4%
if 3.00000000000000007e-80 < C Initial program 24.8%
Taylor expanded in C around inf 64.2%
Taylor expanded in A around inf 64.2%
(FPCore (A B C)
:precision binary64
(if (<= C -1.5e+68)
(/ (* 180.0 (atan (/ C B))) PI)
(if (<= C 1.2e-218)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(if (<= C 1.85e-78)
(* 180.0 (/ (atan (- 1.0 (/ A B))) PI))
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -1.5e+68) {
tmp = (180.0 * atan((C / B))) / ((double) M_PI);
} else if (C <= 1.2e-218) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else if (C <= 1.85e-78) {
tmp = 180.0 * (atan((1.0 - (A / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -1.5e+68) {
tmp = (180.0 * Math.atan((C / B))) / Math.PI;
} else if (C <= 1.2e-218) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else if (C <= 1.85e-78) {
tmp = 180.0 * (Math.atan((1.0 - (A / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -1.5e+68: tmp = (180.0 * math.atan((C / B))) / math.pi elif C <= 1.2e-218: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) elif C <= 1.85e-78: tmp = 180.0 * (math.atan((1.0 - (A / B))) / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -1.5e+68) tmp = Float64(Float64(180.0 * atan(Float64(C / B))) / pi); elseif (C <= 1.2e-218) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); elseif (C <= 1.85e-78) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(A / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -1.5e+68) tmp = (180.0 * atan((C / B))) / pi; elseif (C <= 1.2e-218) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); elseif (C <= 1.85e-78) tmp = 180.0 * (atan((1.0 - (A / B))) / pi); else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -1.5e+68], N[(N[(180.0 * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 1.2e-218], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 1.85e-78], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.5 \cdot 10^{+68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 1.2 \cdot 10^{-218}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 1.85 \cdot 10^{-78}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -1.5000000000000001e68Initial program 76.7%
associate-*r/76.7%
Applied egg-rr93.6%
Taylor expanded in B around -inf 79.0%
associate--l+79.0%
div-sub83.5%
Simplified83.5%
Taylor expanded in C around inf 72.9%
if -1.5000000000000001e68 < C < 1.2e-218Initial program 66.1%
Taylor expanded in C around 0 58.6%
associate-*r/58.6%
mul-1-neg58.6%
unpow258.6%
unpow258.6%
hypot-define77.5%
Simplified77.5%
Taylor expanded in A around 0 53.9%
Taylor expanded in A around 0 53.9%
associate-*r/53.9%
neg-mul-153.9%
+-commutative53.9%
distribute-neg-in53.9%
sub-neg53.9%
mul-1-neg53.9%
div-sub53.9%
mul-1-neg53.9%
distribute-frac-neg53.9%
*-inverses53.9%
metadata-eval53.9%
Simplified53.9%
if 1.2e-218 < C < 1.85000000000000003e-78Initial program 73.1%
Taylor expanded in C around 0 73.2%
associate-*r/73.2%
mul-1-neg73.2%
unpow273.2%
unpow273.2%
hypot-define89.5%
Simplified89.5%
Taylor expanded in B around -inf 76.4%
mul-1-neg76.4%
unsub-neg76.4%
Simplified76.4%
if 1.85000000000000003e-78 < C Initial program 24.8%
Taylor expanded in C around inf 64.2%
Taylor expanded in A around inf 64.2%
(FPCore (A B C)
:precision binary64
(if (<= B -3.3e-102)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -1.06e-220)
(/ (* 180.0 (atan 0.0)) PI)
(if (<= B 1.32e+24)
(/ (* 180.0 (atan (/ C B))) PI)
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -3.3e-102) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -1.06e-220) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else if (B <= 1.32e+24) {
tmp = (180.0 * atan((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 <= -3.3e-102) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -1.06e-220) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else if (B <= 1.32e+24) {
tmp = (180.0 * Math.atan((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 <= -3.3e-102: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -1.06e-220: tmp = (180.0 * math.atan(0.0)) / math.pi elif B <= 1.32e+24: tmp = (180.0 * math.atan((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 <= -3.3e-102) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -1.06e-220) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); elseif (B <= 1.32e+24) tmp = Float64(Float64(180.0 * atan(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 <= -3.3e-102) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -1.06e-220) tmp = (180.0 * atan(0.0)) / pi; elseif (B <= 1.32e+24) tmp = (180.0 * atan((C / B))) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -3.3e-102], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.06e-220], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 1.32e+24], N[(N[(180.0 * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -3.3 \cdot 10^{-102}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -1.06 \cdot 10^{-220}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{elif}\;B \leq 1.32 \cdot 10^{+24}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -3.3e-102Initial program 51.0%
Taylor expanded in B around -inf 52.0%
if -3.3e-102 < B < -1.06000000000000004e-220Initial program 33.6%
associate-*r/33.6%
Applied egg-rr74.0%
div-inv74.0%
Applied egg-rr74.0%
Taylor expanded in C around inf 44.2%
distribute-rgt1-in44.2%
metadata-eval44.2%
mul0-lft44.2%
div044.2%
metadata-eval44.2%
Simplified44.2%
if -1.06000000000000004e-220 < B < 1.32000000000000012e24Initial program 68.5%
associate-*r/68.5%
Applied egg-rr82.1%
Taylor expanded in B around -inf 51.7%
associate--l+51.7%
div-sub56.6%
Simplified56.6%
Taylor expanded in C around inf 37.0%
if 1.32000000000000012e24 < B Initial program 47.4%
Taylor expanded in B around inf 61.1%
(FPCore (A B C)
:precision binary64
(if (<= C -1.4e+67)
(/ (* 180.0 (atan (/ C B))) PI)
(if (<= C 3.4e+62)
(* 180.0 (/ (atan (- -1.0 (/ A B))) PI))
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (C <= -1.4e+67) {
tmp = (180.0 * atan((C / B))) / ((double) M_PI);
} else if (C <= 3.4e+62) {
tmp = 180.0 * (atan((-1.0 - (A / B))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -1.4e+67) {
tmp = (180.0 * Math.atan((C / B))) / Math.PI;
} else if (C <= 3.4e+62) {
tmp = 180.0 * (Math.atan((-1.0 - (A / B))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -1.4e+67: tmp = (180.0 * math.atan((C / B))) / math.pi elif C <= 3.4e+62: tmp = 180.0 * (math.atan((-1.0 - (A / B))) / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -1.4e+67) tmp = Float64(Float64(180.0 * atan(Float64(C / B))) / pi); elseif (C <= 3.4e+62) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - Float64(A / B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -1.4e+67) tmp = (180.0 * atan((C / B))) / pi; elseif (C <= 3.4e+62) tmp = 180.0 * (atan((-1.0 - (A / B))) / pi); else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -1.4e+67], N[(N[(180.0 * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 3.4e+62], N[(180.0 * N[(N[ArcTan[N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.4 \cdot 10^{+67}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 3.4 \cdot 10^{+62}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -1.3999999999999999e67Initial program 76.7%
associate-*r/76.7%
Applied egg-rr93.6%
Taylor expanded in B around -inf 79.0%
associate--l+79.0%
div-sub83.5%
Simplified83.5%
Taylor expanded in C around inf 72.9%
if -1.3999999999999999e67 < C < 3.40000000000000014e62Initial program 62.8%
Taylor expanded in C around 0 58.4%
associate-*r/58.4%
mul-1-neg58.4%
unpow258.4%
unpow258.4%
hypot-define78.5%
Simplified78.5%
Taylor expanded in A around 0 52.9%
Taylor expanded in A around 0 52.9%
associate-*r/52.9%
neg-mul-152.9%
+-commutative52.9%
distribute-neg-in52.9%
sub-neg52.9%
mul-1-neg52.9%
div-sub52.9%
mul-1-neg52.9%
distribute-frac-neg52.9%
*-inverses52.9%
metadata-eval52.9%
Simplified52.9%
if 3.40000000000000014e62 < C Initial program 20.1%
Taylor expanded in C around inf 76.0%
Taylor expanded in A around inf 76.0%
(FPCore (A B C)
:precision binary64
(if (<= C -8e-127)
(/ (* 180.0 (atan (/ C B))) PI)
(if (<= C 1e-80)
(* 180.0 (/ (atan (/ A (- B))) PI))
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (C <= -8e-127) {
tmp = (180.0 * atan((C / B))) / ((double) M_PI);
} else if (C <= 1e-80) {
tmp = 180.0 * (atan((A / -B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -8e-127) {
tmp = (180.0 * Math.atan((C / B))) / Math.PI;
} else if (C <= 1e-80) {
tmp = 180.0 * (Math.atan((A / -B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -8e-127: tmp = (180.0 * math.atan((C / B))) / math.pi elif C <= 1e-80: tmp = 180.0 * (math.atan((A / -B)) / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -8e-127) tmp = Float64(Float64(180.0 * atan(Float64(C / B))) / pi); elseif (C <= 1e-80) tmp = Float64(180.0 * Float64(atan(Float64(A / Float64(-B))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -8e-127) tmp = (180.0 * atan((C / B))) / pi; elseif (C <= 1e-80) tmp = 180.0 * (atan((A / -B)) / pi); else tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -8e-127], N[(N[(180.0 * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 1e-80], N[(180.0 * N[(N[ArcTan[N[(A / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -8 \cdot 10^{-127}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 10^{-80}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{-B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\end{array}
\end{array}
if C < -8.0000000000000002e-127Initial program 70.5%
associate-*r/70.5%
Applied egg-rr90.8%
Taylor expanded in B around -inf 69.3%
associate--l+69.3%
div-sub71.6%
Simplified71.6%
Taylor expanded in C around inf 54.9%
if -8.0000000000000002e-127 < C < 9.99999999999999961e-81Initial program 70.1%
Taylor expanded in C around 0 69.3%
associate-*r/69.3%
mul-1-neg69.3%
unpow269.3%
unpow269.3%
hypot-define84.5%
Simplified84.5%
Taylor expanded in A around 0 59.4%
Taylor expanded in A around inf 40.3%
associate-*r/40.3%
mul-1-neg40.3%
Simplified40.3%
if 9.99999999999999961e-81 < C Initial program 24.8%
Taylor expanded in C around inf 64.2%
Taylor expanded in A around inf 64.2%
Final simplification53.1%
(FPCore (A B C)
:precision binary64
(if (<= B -8.2e+29)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 2.4e+58)
(* 180.0 (/ (atan (/ A (- B))) PI))
(* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -8.2e+29) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 2.4e+58) {
tmp = 180.0 * (atan((A / -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 <= -8.2e+29) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 2.4e+58) {
tmp = 180.0 * (Math.atan((A / -B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -8.2e+29: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 2.4e+58: tmp = 180.0 * (math.atan((A / -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 <= -8.2e+29) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 2.4e+58) tmp = Float64(180.0 * Float64(atan(Float64(A / Float64(-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 <= -8.2e+29) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 2.4e+58) tmp = 180.0 * (atan((A / -B)) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -8.2e+29], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.4e+58], N[(180.0 * N[(N[ArcTan[N[(A / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -8.2 \cdot 10^{+29}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 2.4 \cdot 10^{+58}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{-B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -8.2000000000000007e29Initial program 46.7%
Taylor expanded in B around -inf 70.3%
if -8.2000000000000007e29 < B < 2.4e58Initial program 61.6%
Taylor expanded in C around 0 51.7%
associate-*r/51.7%
mul-1-neg51.7%
unpow251.7%
unpow251.7%
hypot-define59.4%
Simplified59.4%
Taylor expanded in A around 0 44.8%
Taylor expanded in A around inf 39.6%
associate-*r/39.6%
mul-1-neg39.6%
Simplified39.6%
if 2.4e58 < B Initial program 43.3%
Taylor expanded in B around inf 66.8%
Final simplification50.3%
(FPCore (A B C)
:precision binary64
(if (<= B -8.6e-101)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 9e-138)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -8.6e-101) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 9e-138) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -8.6e-101) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 9e-138) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -8.6e-101: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 9e-138: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -8.6e-101) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 9e-138) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -8.6e-101) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 9e-138) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -8.6e-101], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 9e-138], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -8.6 \cdot 10^{-101}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 9 \cdot 10^{-138}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -8.5999999999999995e-101Initial program 51.0%
Taylor expanded in B around -inf 52.0%
if -8.5999999999999995e-101 < B < 9.00000000000000016e-138Initial program 58.8%
associate-*r/58.8%
Applied egg-rr83.9%
div-inv83.9%
Applied egg-rr83.9%
Taylor expanded in C around inf 32.2%
distribute-rgt1-in32.2%
metadata-eval32.2%
mul0-lft32.2%
div032.2%
metadata-eval32.2%
Simplified32.2%
if 9.00000000000000016e-138 < B Initial program 56.4%
Taylor expanded in B around inf 46.0%
(FPCore (A B C) :precision binary64 (if (<= B -5e-310) (* 180.0 (/ (atan 1.0) PI)) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5e-310) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -5e-310) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5e-310: tmp = 180.0 * (math.atan(1.0) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5e-310) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5e-310) tmp = 180.0 * (atan(1.0) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5e-310], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5 \cdot 10^{-310}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -4.999999999999985e-310Initial program 53.2%
Taylor expanded in B around -inf 36.3%
if -4.999999999999985e-310 < B Initial program 58.0%
Taylor expanded in B around inf 36.4%
(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.6%
Taylor expanded in B around inf 18.8%
herbie shell --seed 2024125
(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)))