
(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 30 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 4.4e+101) (/ (* 180.0 (atan (/ (- (- C A) (hypot (- A C) B)) B))) PI) (* (/ 180.0 PI) (atan (* B (/ -0.5 C))))))
double code(double A, double B, double C) {
double tmp;
if (C <= 4.4e+101) {
tmp = (180.0 * atan((((C - A) - hypot((A - C), B)) / B))) / ((double) M_PI);
} else {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 4.4e+101) {
tmp = (180.0 * Math.atan((((C - A) - Math.hypot((A - C), B)) / B))) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 4.4e+101: tmp = (180.0 * math.atan((((C - A) - math.hypot((A - C), B)) / B))) / math.pi else: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 4.4e+101) tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B))) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 4.4e+101) tmp = (180.0 * atan((((C - A) - hypot((A - C), B)) / B))) / pi; else tmp = (180.0 / pi) * atan((B * (-0.5 / C))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 4.4e+101], N[(N[(180.0 * N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 4.4 \cdot 10^{+101}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\end{array}
\end{array}
if C < 4.4000000000000001e101Initial program 56.3%
associate-*r/56.3%
associate-*l/56.3%
*-un-lft-identity56.3%
unpow256.3%
unpow256.3%
hypot-define83.2%
Applied egg-rr83.2%
if 4.4000000000000001e101 < C Initial program 12.5%
Applied egg-rr41.9%
Taylor expanded in C around inf 83.9%
distribute-rgt1-in83.9%
metadata-eval83.9%
mul0-lft83.9%
div083.9%
metadata-eval83.9%
metadata-eval83.9%
cancel-sign-sub-inv83.9%
neg-sub083.9%
distribute-lft-neg-in83.9%
metadata-eval83.9%
associate-*r/83.9%
*-commutative83.9%
associate-/l*83.8%
Simplified83.8%
Taylor expanded in B around 0 83.8%
associate-*r/83.8%
associate-*r/83.8%
*-commutative83.8%
associate-*r/83.7%
associate-*l/84.0%
Simplified84.0%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e-37)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 5.2e-34)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(* 180.0 (/ (atan (* (+ A (hypot B A)) (/ -1.0 B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 5.2e-34) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((A + hypot(B, A)) * (-1.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 5.2e-34) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((A + Math.hypot(B, A)) * (-1.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 5.2e-34: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) else: tmp = 180.0 * (math.atan(((A + math.hypot(B, A)) * (-1.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 5.2e-34) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(A + hypot(B, A)) * Float64(-1.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 5.2e-34) tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); else tmp = 180.0 * (atan(((A + hypot(B, A)) * (-1.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 5.2e-34], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(A + N[Sqrt[B ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision] * N[(-1.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 5.2 \cdot 10^{-34}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\left(A + \mathsf{hypot}\left(B, A\right)\right) \cdot \frac{-1}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A < 5.1999999999999999e-34Initial program 53.7%
Taylor expanded in A around 0 52.1%
unpow252.1%
unpow252.1%
hypot-define79.0%
Simplified79.0%
if 5.1999999999999999e-34 < A Initial program 77.7%
Taylor expanded in C around 0 72.9%
mul-1-neg72.9%
+-commutative72.9%
unpow272.9%
unpow272.9%
hypot-define87.5%
Simplified87.5%
Final simplification78.2%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e-37)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 5e-27)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(/ (* 180.0 (atan (/ (+ A (hypot A B)) (- B)))) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 5e-27) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / 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 <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 5e-27) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / 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 <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 5e-27: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / 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 <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 5e-27) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(Float64(180.0 * atan(Float64(Float64(A + hypot(A, B)) / Float64(-B)))) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 5e-27) tmp = 180.0 * (atan(((C - hypot(B, C)) / 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, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 5e-27], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 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 -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 5 \cdot 10^{-27}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\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 < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A < 5.0000000000000002e-27Initial program 53.7%
Taylor expanded in A around 0 52.1%
unpow252.1%
unpow252.1%
hypot-define79.0%
Simplified79.0%
if 5.0000000000000002e-27 < A Initial program 77.7%
associate-*r/77.7%
associate-*l/77.7%
*-un-lft-identity77.7%
unpow277.7%
unpow277.7%
hypot-define94.9%
Applied egg-rr94.9%
Taylor expanded in C around 0 72.9%
mul-1-neg72.9%
distribute-neg-frac272.9%
unpow272.9%
unpow272.9%
hypot-define87.5%
Simplified87.5%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e-37)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 1.16e-21)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(/ 180.0 (/ PI (atan (/ (+ A (hypot A B)) (- B))))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 1.16e-21) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / 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 <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 1.16e-21) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / 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 <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 1.16e-21: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / 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 <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 1.16e-21) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(180.0 / Float64(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 <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 1.16e-21) tmp = 180.0 * (atan(((C - hypot(B, C)) / 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, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.16e-21], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(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}
\mathbf{if}\;A \leq -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.16 \cdot 10^{-21}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)}}\\
\end{array}
\end{array}
if A < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A < 1.1600000000000001e-21Initial program 53.7%
Taylor expanded in A around 0 52.1%
unpow252.1%
unpow252.1%
hypot-define79.0%
Simplified79.0%
if 1.1600000000000001e-21 < A Initial program 77.7%
Applied egg-rr94.8%
Taylor expanded in C around 0 72.9%
mul-1-neg72.9%
distribute-neg-frac272.9%
unpow272.9%
unpow272.9%
hypot-define87.5%
Simplified87.4%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e-37)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 1.65e-36)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(* 180.0 (/ (atan (/ (+ A (hypot B A)) (- B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 1.65e-36) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((A + hypot(B, A)) / -B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 1.65e-36) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((A + Math.hypot(B, A)) / -B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 1.65e-36: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) else: tmp = 180.0 * (math.atan(((A + math.hypot(B, A)) / -B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 1.65e-36) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(A + hypot(B, A)) / Float64(-B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 1.65e-36) tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); else tmp = 180.0 * (atan(((A + hypot(B, A)) / -B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.65e-36], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(A + N[Sqrt[B ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.65 \cdot 10^{-36}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A + \mathsf{hypot}\left(B, A\right)}{-B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A < 1.64999999999999995e-36Initial program 53.7%
Taylor expanded in A around 0 52.1%
unpow252.1%
unpow252.1%
hypot-define79.0%
Simplified79.0%
if 1.64999999999999995e-36 < A Initial program 77.7%
Taylor expanded in C around 0 72.9%
mul-1-neg72.9%
distribute-neg-frac272.9%
+-commutative72.9%
unpow272.9%
unpow272.9%
hypot-define87.4%
Simplified87.4%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e-37)
(/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI)
(if (<= A 9.6e-16)
(* 180.0 (/ (atan (/ (- C (hypot B C)) B)) PI))
(* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else if (A <= 9.6e-16) {
tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else if (A <= 9.6e-16) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(B, C)) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((1.0 - ((A - C) / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi elif A <= 9.6e-16: tmp = 180.0 * (math.atan(((C - math.hypot(B, C)) / B)) / math.pi) else: tmp = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); elseif (A <= 9.6e-16) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(B, C)) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(1.0 - Float64(Float64(A - C) / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; elseif (A <= 9.6e-16) tmp = 180.0 * (atan(((C - hypot(B, C)) / B)) / pi); else tmp = 180.0 * (atan((1.0 - ((A - C) / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 9.6e-16], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[B ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 - N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 9.6 \cdot 10^{-16}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(B, C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - \frac{A - C}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A < 9.60000000000000019e-16Initial program 53.7%
Taylor expanded in A around 0 52.1%
unpow252.1%
unpow252.1%
hypot-define79.0%
Simplified79.0%
if 9.60000000000000019e-16 < A Initial program 77.7%
Taylor expanded in B around -inf 84.4%
associate--l+84.4%
div-sub84.4%
Simplified84.4%
Final simplification77.5%
(FPCore (A B C) :precision binary64 (if (<= C 5.8e+100) (* 180.0 (/ (atan (/ (- (- C A) (hypot B (- A C))) B)) PI)) (* (/ 180.0 PI) (atan (* B (/ -0.5 C))))))
double code(double A, double B, double C) {
double tmp;
if (C <= 5.8e+100) {
tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 5.8e+100) {
tmp = 180.0 * (Math.atan((((C - A) - Math.hypot(B, (A - C))) / B)) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 5.8e+100: tmp = 180.0 * (math.atan((((C - A) - math.hypot(B, (A - C))) / B)) / math.pi) else: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 5.8e+100) tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 5.8e+100) tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / pi); else tmp = (180.0 / pi) * atan((B * (-0.5 / C))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 5.8e+100], 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[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 5.8 \cdot 10^{+100}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\end{array}
\end{array}
if C < 5.8000000000000001e100Initial program 56.3%
associate-*l/56.3%
*-lft-identity56.3%
+-commutative56.3%
unpow256.3%
unpow256.3%
hypot-define83.1%
Simplified83.1%
if 5.8000000000000001e100 < C Initial program 12.5%
Applied egg-rr41.9%
Taylor expanded in C around inf 83.9%
distribute-rgt1-in83.9%
metadata-eval83.9%
mul0-lft83.9%
div083.9%
metadata-eval83.9%
metadata-eval83.9%
cancel-sign-sub-inv83.9%
neg-sub083.9%
distribute-lft-neg-in83.9%
metadata-eval83.9%
associate-*r/83.9%
*-commutative83.9%
associate-/l*83.8%
Simplified83.8%
Taylor expanded in B around 0 83.8%
associate-*r/83.8%
associate-*r/83.8%
*-commutative83.8%
associate-*r/83.7%
associate-*l/84.0%
Simplified84.0%
(FPCore (A B C) :precision binary64 (if (<= A -1.9e-37) (/ (* 180.0 (atan (/ (* 0.5 (+ B (* B (/ C A)))) A))) PI) (* 180.0 (/ (atan (/ (- C (+ A (hypot B (- A C)))) B)) PI))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e-37) {
tmp = (180.0 * Math.atan(((0.5 * (B + (B * (C / A)))) / A))) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(((C - (A + Math.hypot(B, (A - C)))) / B)) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.9e-37: tmp = (180.0 * math.atan(((0.5 * (B + (B * (C / A)))) / A))) / math.pi else: tmp = 180.0 * (math.atan(((C - (A + math.hypot(B, (A - C)))) / B)) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.9e-37) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * Float64(B + Float64(B * Float64(C / A)))) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(A - C)))) / B)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e-37) tmp = (180.0 * atan(((0.5 * (B + (B * (C / A)))) / A))) / pi; else tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.9e-37], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(B + N[(B * N[(C / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[(A + N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.9 \cdot 10^{-37}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \left(B + B \cdot \frac{C}{A}\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(B, A - C\right)\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.9000000000000002e-37Initial program 22.2%
associate-*r/22.2%
associate-*l/22.2%
*-un-lft-identity22.2%
unpow222.2%
unpow222.2%
hypot-define57.9%
Applied egg-rr57.9%
Taylor expanded in A around -inf 68.1%
associate-*r/68.1%
distribute-lft-out68.1%
associate-*r*68.1%
metadata-eval68.1%
associate-/l*69.7%
Simplified69.7%
if -1.9000000000000002e-37 < A Initial program 61.2%
Simplified85.0%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))
(if (<= B -2.1e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -3e-215)
t_0
(if (<= B 1.7e-185)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 3.9e-41)
(* 180.0 (/ (atan (* (/ C B) 2.0)) PI))
(if (<= B 3.8e-23) t_0 (* 180.0 (/ (atan -1.0) PI)))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
double tmp;
if (B <= -2.1e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -3e-215) {
tmp = t_0;
} else if (B <= 1.7e-185) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 3.9e-41) {
tmp = 180.0 * (atan(((C / B) * 2.0)) / ((double) M_PI));
} else if (B <= 3.8e-23) {
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((-0.5 * (B / C))) / Math.PI);
double tmp;
if (B <= -2.1e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -3e-215) {
tmp = t_0;
} else if (B <= 1.7e-185) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 3.9e-41) {
tmp = 180.0 * (Math.atan(((C / B) * 2.0)) / Math.PI);
} else if (B <= 3.8e-23) {
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((-0.5 * (B / C))) / math.pi) tmp = 0 if B <= -2.1e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -3e-215: tmp = t_0 elif B <= 1.7e-185: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 3.9e-41: tmp = 180.0 * (math.atan(((C / B) * 2.0)) / math.pi) elif B <= 3.8e-23: 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(-0.5 * Float64(B / C))) / pi)) tmp = 0.0 if (B <= -2.1e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -3e-215) tmp = t_0; elseif (B <= 1.7e-185) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 3.9e-41) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) * 2.0)) / pi)); elseif (B <= 3.8e-23) 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((-0.5 * (B / C))) / pi); tmp = 0.0; if (B <= -2.1e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -3e-215) tmp = t_0; elseif (B <= 1.7e-185) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 3.9e-41) tmp = 180.0 * (atan(((C / B) * 2.0)) / pi); elseif (B <= 3.8e-23) 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[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -2.1e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -3e-215], t$95$0, If[LessEqual[B, 1.7e-185], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.9e-41], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.8e-23], 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(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{if}\;B \leq -2.1 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -3 \cdot 10^{-215}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 1.7 \cdot 10^{-185}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.9 \cdot 10^{-41}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} \cdot 2\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.8 \cdot 10^{-23}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.1e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -2.1e-18 < B < -3.00000000000000025e-215 or 3.89999999999999991e-41 < B < 3.80000000000000011e-23Initial program 36.4%
Taylor expanded in C around inf 50.6%
Taylor expanded in A around inf 50.6%
if -3.00000000000000025e-215 < B < 1.6999999999999999e-185Initial program 65.3%
Taylor expanded in A around inf 51.5%
if 1.6999999999999999e-185 < B < 3.89999999999999991e-41Initial program 56.2%
Taylor expanded in C around -inf 39.7%
if 3.80000000000000011e-23 < B Initial program 54.3%
Taylor expanded in B around inf 60.0%
Final simplification57.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI)))
(t_1 (* 180.0 (/ (atan (* (/ A B) -2.0)) PI))))
(if (<= B -3e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -8.1e-218)
t_0
(if (<= B 1.1e-227)
t_1
(if (<= B 3.8e-28)
t_0
(if (<= B 1.65e-17) t_1 (* 180.0 (/ (atan -1.0) PI)))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
double t_1 = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
double tmp;
if (B <= -3e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -8.1e-218) {
tmp = t_0;
} else if (B <= 1.1e-227) {
tmp = t_1;
} else if (B <= 3.8e-28) {
tmp = t_0;
} else if (B <= 1.65e-17) {
tmp = t_1;
} 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((-0.5 * (B / C))) / Math.PI);
double t_1 = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
double tmp;
if (B <= -3e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -8.1e-218) {
tmp = t_0;
} else if (B <= 1.1e-227) {
tmp = t_1;
} else if (B <= 3.8e-28) {
tmp = t_0;
} else if (B <= 1.65e-17) {
tmp = t_1;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) t_1 = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) tmp = 0 if B <= -3e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -8.1e-218: tmp = t_0 elif B <= 1.1e-227: tmp = t_1 elif B <= 3.8e-28: tmp = t_0 elif B <= 1.65e-17: tmp = t_1 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(-0.5 * Float64(B / C))) / pi)) t_1 = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)) tmp = 0.0 if (B <= -3e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -8.1e-218) tmp = t_0; elseif (B <= 1.1e-227) tmp = t_1; elseif (B <= 3.8e-28) tmp = t_0; elseif (B <= 1.65e-17) tmp = t_1; 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((-0.5 * (B / C))) / pi); t_1 = 180.0 * (atan(((A / B) * -2.0)) / pi); tmp = 0.0; if (B <= -3e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -8.1e-218) tmp = t_0; elseif (B <= 1.1e-227) tmp = t_1; elseif (B <= 3.8e-28) tmp = t_0; elseif (B <= 1.65e-17) tmp = t_1; 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[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B, -3e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -8.1e-218], t$95$0, If[LessEqual[B, 1.1e-227], t$95$1, If[LessEqual[B, 3.8e-28], t$95$0, If[LessEqual[B, 1.65e-17], t$95$1, 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(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
t_1 := 180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{if}\;B \leq -3 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -8.1 \cdot 10^{-218}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 1.1 \cdot 10^{-227}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;B \leq 3.8 \cdot 10^{-28}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 1.65 \cdot 10^{-17}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.99999999999999983e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -2.99999999999999983e-18 < B < -8.09999999999999988e-218 or 1.0999999999999999e-227 < B < 3.80000000000000009e-28Initial program 42.8%
Taylor expanded in C around inf 40.4%
Taylor expanded in A around inf 40.4%
if -8.09999999999999988e-218 < B < 1.0999999999999999e-227 or 3.80000000000000009e-28 < B < 1.65e-17Initial program 71.4%
Taylor expanded in A around inf 58.8%
if 1.65e-17 < B Initial program 54.4%
Taylor expanded in B around inf 61.5%
Final simplification57.0%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)))
(if (<= B -1.45e-31)
(/ (* 180.0 (atan (- 1.0 t_0))) PI)
(if (<= B -1.72e-217)
(/ (* 180.0 (atan (* 0.5 (* B (/ (+ (/ C A) 1.0) A))))) PI)
(if (<= B 7e-155)
(/ (* 180.0 (atan (- -1.0 t_0))) PI)
(if (<= B 2.5e-108)
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))
(* 180.0 (/ (atan (+ (/ C B) (- -1.0 (/ A B)))) PI))))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -1.45e-31) {
tmp = (180.0 * atan((1.0 - t_0))) / ((double) M_PI);
} else if (B <= -1.72e-217) {
tmp = (180.0 * atan((0.5 * (B * (((C / A) + 1.0) / A))))) / ((double) M_PI);
} else if (B <= 7e-155) {
tmp = (180.0 * atan((-1.0 - t_0))) / ((double) M_PI);
} else if (B <= 2.5e-108) {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -1.45e-31) {
tmp = (180.0 * Math.atan((1.0 - t_0))) / Math.PI;
} else if (B <= -1.72e-217) {
tmp = (180.0 * Math.atan((0.5 * (B * (((C / A) + 1.0) / A))))) / Math.PI;
} else if (B <= 7e-155) {
tmp = (180.0 * Math.atan((-1.0 - t_0))) / Math.PI;
} else if (B <= 2.5e-108) {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (Math.atan(((C / B) + (-1.0 - (A / B)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B tmp = 0 if B <= -1.45e-31: tmp = (180.0 * math.atan((1.0 - t_0))) / math.pi elif B <= -1.72e-217: tmp = (180.0 * math.atan((0.5 * (B * (((C / A) + 1.0) / A))))) / math.pi elif B <= 7e-155: tmp = (180.0 * math.atan((-1.0 - t_0))) / math.pi elif B <= 2.5e-108: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) else: tmp = 180.0 * (math.atan(((C / B) + (-1.0 - (A / B)))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) tmp = 0.0 if (B <= -1.45e-31) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - t_0))) / pi); elseif (B <= -1.72e-217) tmp = Float64(Float64(180.0 * atan(Float64(0.5 * Float64(B * Float64(Float64(Float64(C / A) + 1.0) / A))))) / pi); elseif (B <= 7e-155) tmp = Float64(Float64(180.0 * atan(Float64(-1.0 - t_0))) / pi); elseif (B <= 2.5e-108) tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + Float64(-1.0 - Float64(A / B)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; tmp = 0.0; if (B <= -1.45e-31) tmp = (180.0 * atan((1.0 - t_0))) / pi; elseif (B <= -1.72e-217) tmp = (180.0 * atan((0.5 * (B * (((C / A) + 1.0) / A))))) / pi; elseif (B <= 7e-155) tmp = (180.0 * atan((-1.0 - t_0))) / pi; elseif (B <= 2.5e-108) tmp = 180.0 / (pi / atan((0.5 * (B / A)))); else tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, -1.45e-31], N[(N[(180.0 * N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -1.72e-217], N[(N[(180.0 * N[ArcTan[N[(0.5 * N[(B * N[(N[(N[(C / A), $MachinePrecision] + 1.0), $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 7e-155], N[(N[(180.0 * N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 2.5e-108], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
\mathbf{if}\;B \leq -1.45 \cdot 10^{-31}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq -1.72 \cdot 10^{-217}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(0.5 \cdot \left(B \cdot \frac{\frac{C}{A} + 1}{A}\right)\right)}{\pi}\\
\mathbf{elif}\;B \leq 7 \cdot 10^{-155}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(-1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.5 \cdot 10^{-108}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + \left(-1 - \frac{A}{B}\right)\right)}{\pi}\\
\end{array}
\end{array}
if B < -1.45e-31Initial program 43.4%
associate-*r/43.3%
associate-*l/43.3%
*-un-lft-identity43.3%
unpow243.3%
unpow243.3%
hypot-define85.1%
Applied egg-rr85.1%
Taylor expanded in B around -inf 81.5%
associate--l+81.5%
div-sub81.5%
Simplified81.5%
if -1.45e-31 < B < -1.72e-217Initial program 30.7%
associate-*r/30.7%
associate-*l/30.7%
*-un-lft-identity30.7%
unpow230.7%
unpow230.7%
hypot-define55.2%
Applied egg-rr55.2%
Taylor expanded in A around -inf 44.6%
associate-*r/44.6%
distribute-lft-out44.6%
associate-*r*44.6%
metadata-eval44.6%
associate-/l*44.9%
Simplified44.9%
Taylor expanded in B around 0 44.9%
associate-/l*44.9%
Simplified44.9%
if -1.72e-217 < B < 7.00000000000000031e-155Initial program 65.7%
associate-*r/65.7%
associate-*l/65.7%
*-un-lft-identity65.7%
unpow265.7%
unpow265.7%
hypot-define83.4%
Applied egg-rr83.4%
Taylor expanded in B around inf 61.7%
+-commutative61.7%
associate--r+61.7%
div-sub61.9%
Simplified61.9%
if 7.00000000000000031e-155 < B < 2.5e-108Initial program 33.6%
Applied egg-rr52.9%
Taylor expanded in A around -inf 80.3%
if 2.5e-108 < B Initial program 56.1%
Taylor expanded in B around inf 73.7%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)))
(if (<= B -8.5e-32)
(/ (* 180.0 (atan (- 1.0 t_0))) PI)
(if (<= B -1.25e-217)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 6.8e-155)
(/ (* 180.0 (atan (- -1.0 t_0))) PI)
(if (<= B 1.9e-108)
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))
(* 180.0 (/ (atan (+ (/ C B) (- -1.0 (/ A B)))) PI))))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * atan((1.0 - t_0))) / ((double) M_PI);
} else if (B <= -1.25e-217) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 6.8e-155) {
tmp = (180.0 * atan((-1.0 - t_0))) / ((double) M_PI);
} else if (B <= 1.9e-108) {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * Math.atan((1.0 - t_0))) / Math.PI;
} else if (B <= -1.25e-217) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 6.8e-155) {
tmp = (180.0 * Math.atan((-1.0 - t_0))) / Math.PI;
} else if (B <= 1.9e-108) {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (Math.atan(((C / B) + (-1.0 - (A / B)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B tmp = 0 if B <= -8.5e-32: tmp = (180.0 * math.atan((1.0 - t_0))) / math.pi elif B <= -1.25e-217: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 6.8e-155: tmp = (180.0 * math.atan((-1.0 - t_0))) / math.pi elif B <= 1.9e-108: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) else: tmp = 180.0 * (math.atan(((C / B) + (-1.0 - (A / B)))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) tmp = 0.0 if (B <= -8.5e-32) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - t_0))) / pi); elseif (B <= -1.25e-217) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 6.8e-155) tmp = Float64(Float64(180.0 * atan(Float64(-1.0 - t_0))) / pi); elseif (B <= 1.9e-108) tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B) + Float64(-1.0 - Float64(A / B)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; tmp = 0.0; if (B <= -8.5e-32) tmp = (180.0 * atan((1.0 - t_0))) / pi; elseif (B <= -1.25e-217) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 6.8e-155) tmp = (180.0 * atan((-1.0 - t_0))) / pi; elseif (B <= 1.9e-108) tmp = 180.0 / (pi / atan((0.5 * (B / A)))); else tmp = 180.0 * (atan(((C / B) + (-1.0 - (A / B)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, -8.5e-32], N[(N[(180.0 * N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -1.25e-217], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 6.8e-155], N[(N[(180.0 * N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 1.9e-108], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C / B), $MachinePrecision] + N[(-1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
\mathbf{if}\;B \leq -8.5 \cdot 10^{-32}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq -1.25 \cdot 10^{-217}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 6.8 \cdot 10^{-155}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(-1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.9 \cdot 10^{-108}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B} + \left(-1 - \frac{A}{B}\right)\right)}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
associate-*r/43.3%
associate-*l/43.3%
*-un-lft-identity43.3%
unpow243.3%
unpow243.3%
hypot-define85.1%
Applied egg-rr85.1%
Taylor expanded in B around -inf 81.5%
associate--l+81.5%
div-sub81.5%
Simplified81.5%
if -8.5000000000000003e-32 < B < -1.2500000000000001e-217Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if -1.2500000000000001e-217 < B < 6.8e-155Initial program 65.7%
associate-*r/65.7%
associate-*l/65.7%
*-un-lft-identity65.7%
unpow265.7%
unpow265.7%
hypot-define83.4%
Applied egg-rr83.4%
Taylor expanded in B around inf 61.7%
+-commutative61.7%
associate--r+61.7%
div-sub61.9%
Simplified61.9%
if 6.8e-155 < B < 1.89999999999999987e-108Initial program 33.6%
Applied egg-rr52.9%
Taylor expanded in A around -inf 80.3%
if 1.89999999999999987e-108 < B Initial program 56.1%
Taylor expanded in B around inf 73.7%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)))
(if (<= B -8.5e-32)
(/ (* 180.0 (atan (- 1.0 t_0))) PI)
(if (<= B -8.8e-213)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (or (<= B 6.8e-155) (not (<= B 3.2e-108)))
(* 180.0 (/ (atan (- -1.0 t_0)) PI))
(/ 180.0 (/ PI (atan (* 0.5 (/ B A))))))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * atan((1.0 - t_0))) / ((double) M_PI);
} else if (B <= -8.8e-213) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if ((B <= 6.8e-155) || !(B <= 3.2e-108)) {
tmp = 180.0 * (atan((-1.0 - t_0)) / ((double) M_PI));
} else {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * Math.atan((1.0 - t_0))) / Math.PI;
} else if (B <= -8.8e-213) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if ((B <= 6.8e-155) || !(B <= 3.2e-108)) {
tmp = 180.0 * (Math.atan((-1.0 - t_0)) / Math.PI);
} else {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B tmp = 0 if B <= -8.5e-32: tmp = (180.0 * math.atan((1.0 - t_0))) / math.pi elif B <= -8.8e-213: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif (B <= 6.8e-155) or not (B <= 3.2e-108): tmp = 180.0 * (math.atan((-1.0 - t_0)) / math.pi) else: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) tmp = 0.0 if (B <= -8.5e-32) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - t_0))) / pi); elseif (B <= -8.8e-213) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif ((B <= 6.8e-155) || !(B <= 3.2e-108)) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - t_0)) / pi)); else tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; tmp = 0.0; if (B <= -8.5e-32) tmp = (180.0 * atan((1.0 - t_0))) / pi; elseif (B <= -8.8e-213) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif ((B <= 6.8e-155) || ~((B <= 3.2e-108))) tmp = 180.0 * (atan((-1.0 - t_0)) / pi); else tmp = 180.0 / (pi / atan((0.5 * (B / A)))); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, -8.5e-32], N[(N[(180.0 * N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -8.8e-213], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[B, 6.8e-155], N[Not[LessEqual[B, 3.2e-108]], $MachinePrecision]], N[(180.0 * N[(N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
\mathbf{if}\;B \leq -8.5 \cdot 10^{-32}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq -8.8 \cdot 10^{-213}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 6.8 \cdot 10^{-155} \lor \neg \left(B \leq 3.2 \cdot 10^{-108}\right):\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - t\_0\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
associate-*r/43.3%
associate-*l/43.3%
*-un-lft-identity43.3%
unpow243.3%
unpow243.3%
hypot-define85.1%
Applied egg-rr85.1%
Taylor expanded in B around -inf 81.5%
associate--l+81.5%
div-sub81.5%
Simplified81.5%
if -8.5000000000000003e-32 < B < -8.80000000000000039e-213Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if -8.80000000000000039e-213 < B < 6.8e-155 or 3.2e-108 < B Initial program 59.8%
+-commutative59.8%
unpow259.8%
unpow259.8%
hypot-undefine79.8%
sub-neg79.8%
distribute-lft-in70.8%
hypot-undefine57.4%
unpow257.4%
unpow257.4%
+-commutative57.4%
unpow257.4%
unpow257.4%
hypot-define70.8%
Applied egg-rr70.8%
Taylor expanded in B around inf 69.2%
+-commutative69.2%
associate--r+69.2%
div-sub69.2%
sub-neg69.2%
metadata-eval69.2%
Simplified69.2%
if 6.8e-155 < B < 3.2e-108Initial program 33.6%
Applied egg-rr52.9%
Taylor expanded in A around -inf 80.3%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)))
(if (<= B -5.3e-31)
(* (/ 180.0 PI) (atan (- 1.0 t_0)))
(if (<= B -8.8e-213)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (or (<= B 8e-156) (not (<= B 5.8e-108)))
(* 180.0 (/ (atan (- -1.0 t_0)) PI))
(/ 180.0 (/ PI (atan (* 0.5 (/ B A))))))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -5.3e-31) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - t_0));
} else if (B <= -8.8e-213) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if ((B <= 8e-156) || !(B <= 5.8e-108)) {
tmp = 180.0 * (atan((-1.0 - t_0)) / ((double) M_PI));
} else {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -5.3e-31) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - t_0));
} else if (B <= -8.8e-213) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if ((B <= 8e-156) || !(B <= 5.8e-108)) {
tmp = 180.0 * (Math.atan((-1.0 - t_0)) / Math.PI);
} else {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B tmp = 0 if B <= -5.3e-31: tmp = (180.0 / math.pi) * math.atan((1.0 - t_0)) elif B <= -8.8e-213: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif (B <= 8e-156) or not (B <= 5.8e-108): tmp = 180.0 * (math.atan((-1.0 - t_0)) / math.pi) else: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) tmp = 0.0 if (B <= -5.3e-31) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - t_0))); elseif (B <= -8.8e-213) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif ((B <= 8e-156) || !(B <= 5.8e-108)) tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - t_0)) / pi)); else tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; tmp = 0.0; if (B <= -5.3e-31) tmp = (180.0 / pi) * atan((1.0 - t_0)); elseif (B <= -8.8e-213) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif ((B <= 8e-156) || ~((B <= 5.8e-108))) tmp = 180.0 * (atan((-1.0 - t_0)) / pi); else tmp = 180.0 / (pi / atan((0.5 * (B / A)))); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, -5.3e-31], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -8.8e-213], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[B, 8e-156], N[Not[LessEqual[B, 5.8e-108]], $MachinePrecision]], N[(180.0 * N[(N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
\mathbf{if}\;B \leq -5.3 \cdot 10^{-31}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - t\_0\right)\\
\mathbf{elif}\;B \leq -8.8 \cdot 10^{-213}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 8 \cdot 10^{-156} \lor \neg \left(B \leq 5.8 \cdot 10^{-108}\right):\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - t\_0\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\end{array}
\end{array}
if B < -5.3000000000000001e-31Initial program 43.4%
associate-*r/43.3%
associate-*l/43.3%
*-un-lft-identity43.3%
unpow243.3%
unpow243.3%
hypot-define85.1%
Applied egg-rr85.1%
Taylor expanded in B around -inf 81.5%
associate--l+81.5%
div-sub81.5%
Simplified81.5%
Taylor expanded in C around -inf 81.4%
associate-*r/81.5%
*-commutative81.5%
associate-/l*81.4%
mul-1-neg81.4%
unsub-neg81.4%
mul-1-neg81.4%
sub-neg81.4%
Simplified81.4%
if -5.3000000000000001e-31 < B < -8.80000000000000039e-213Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if -8.80000000000000039e-213 < B < 8.00000000000000032e-156 or 5.8000000000000002e-108 < B Initial program 59.8%
+-commutative59.8%
unpow259.8%
unpow259.8%
hypot-undefine79.8%
sub-neg79.8%
distribute-lft-in70.8%
hypot-undefine57.4%
unpow257.4%
unpow257.4%
+-commutative57.4%
unpow257.4%
unpow257.4%
hypot-define70.8%
Applied egg-rr70.8%
Taylor expanded in B around inf 69.2%
+-commutative69.2%
associate--r+69.2%
div-sub69.2%
sub-neg69.2%
metadata-eval69.2%
Simplified69.2%
if 8.00000000000000032e-156 < B < 5.8000000000000002e-108Initial program 33.6%
Applied egg-rr52.9%
Taylor expanded in A around -inf 80.3%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)) (t_1 (atan (- -1.0 t_0))))
(if (<= B -8.5e-32)
(/ (* 180.0 (atan (- 1.0 t_0))) PI)
(if (<= B -6.5e-213)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 2e-155)
(/ (* 180.0 t_1) PI)
(if (<= B 1.75e-108)
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))
(* 180.0 (/ t_1 PI))))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double t_1 = atan((-1.0 - t_0));
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * atan((1.0 - t_0))) / ((double) M_PI);
} else if (B <= -6.5e-213) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 2e-155) {
tmp = (180.0 * t_1) / ((double) M_PI);
} else if (B <= 1.75e-108) {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (t_1 / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double t_1 = Math.atan((-1.0 - t_0));
double tmp;
if (B <= -8.5e-32) {
tmp = (180.0 * Math.atan((1.0 - t_0))) / Math.PI;
} else if (B <= -6.5e-213) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 2e-155) {
tmp = (180.0 * t_1) / Math.PI;
} else if (B <= 1.75e-108) {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (t_1 / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B t_1 = math.atan((-1.0 - t_0)) tmp = 0 if B <= -8.5e-32: tmp = (180.0 * math.atan((1.0 - t_0))) / math.pi elif B <= -6.5e-213: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 2e-155: tmp = (180.0 * t_1) / math.pi elif B <= 1.75e-108: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) else: tmp = 180.0 * (t_1 / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) t_1 = atan(Float64(-1.0 - t_0)) tmp = 0.0 if (B <= -8.5e-32) tmp = Float64(Float64(180.0 * atan(Float64(1.0 - t_0))) / pi); elseif (B <= -6.5e-213) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 2e-155) tmp = Float64(Float64(180.0 * t_1) / pi); elseif (B <= 1.75e-108) tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); else tmp = Float64(180.0 * Float64(t_1 / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; t_1 = atan((-1.0 - t_0)); tmp = 0.0; if (B <= -8.5e-32) tmp = (180.0 * atan((1.0 - t_0))) / pi; elseif (B <= -6.5e-213) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 2e-155) tmp = (180.0 * t_1) / pi; elseif (B <= 1.75e-108) tmp = 180.0 / (pi / atan((0.5 * (B / A)))); else tmp = 180.0 * (t_1 / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, Block[{t$95$1 = N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[B, -8.5e-32], N[(N[(180.0 * N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, -6.5e-213], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2e-155], N[(N[(180.0 * t$95$1), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 1.75e-108], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(t$95$1 / Pi), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
t_1 := \tan^{-1} \left(-1 - t\_0\right)\\
\mathbf{if}\;B \leq -8.5 \cdot 10^{-32}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq -6.5 \cdot 10^{-213}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 2 \cdot 10^{-155}:\\
\;\;\;\;\frac{180 \cdot t\_1}{\pi}\\
\mathbf{elif}\;B \leq 1.75 \cdot 10^{-108}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{t\_1}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
associate-*r/43.3%
associate-*l/43.3%
*-un-lft-identity43.3%
unpow243.3%
unpow243.3%
hypot-define85.1%
Applied egg-rr85.1%
Taylor expanded in B around -inf 81.5%
associate--l+81.5%
div-sub81.5%
Simplified81.5%
if -8.5000000000000003e-32 < B < -6.5e-213Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if -6.5e-213 < B < 2.00000000000000003e-155Initial program 65.7%
associate-*r/65.7%
associate-*l/65.7%
*-un-lft-identity65.7%
unpow265.7%
unpow265.7%
hypot-define83.4%
Applied egg-rr83.4%
Taylor expanded in B around inf 61.7%
+-commutative61.7%
associate--r+61.7%
div-sub61.9%
Simplified61.9%
if 2.00000000000000003e-155 < B < 1.7499999999999999e-108Initial program 33.6%
Applied egg-rr52.9%
Taylor expanded in A around -inf 80.3%
if 1.7499999999999999e-108 < B Initial program 56.1%
+-commutative56.1%
unpow256.1%
unpow256.1%
hypot-undefine77.6%
sub-neg77.6%
distribute-lft-in76.3%
hypot-undefine56.1%
unpow256.1%
unpow256.1%
+-commutative56.1%
unpow256.1%
unpow256.1%
hypot-define76.3%
Applied egg-rr76.3%
Taylor expanded in B around inf 73.7%
+-commutative73.7%
associate--r+73.7%
div-sub73.7%
sub-neg73.7%
metadata-eval73.7%
Simplified73.7%
Final simplification70.3%
(FPCore (A B C)
:precision binary64
(if (<= B -1.5e-17)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -9.2e-218)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (or (<= B 6.2e-155) (not (<= B 1.5e-47)))
(/ 180.0 (/ PI (atan (/ (+ A B) (- B)))))
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -1.5e-17) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -9.2e-218) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if ((B <= 6.2e-155) || !(B <= 1.5e-47)) {
tmp = 180.0 / (((double) M_PI) / atan(((A + B) / -B)));
} else {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -1.5e-17) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -9.2e-218) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if ((B <= 6.2e-155) || !(B <= 1.5e-47)) {
tmp = 180.0 / (Math.PI / Math.atan(((A + B) / -B)));
} else {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -1.5e-17: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -9.2e-218: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif (B <= 6.2e-155) or not (B <= 1.5e-47): tmp = 180.0 / (math.pi / math.atan(((A + B) / -B))) else: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -1.5e-17) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -9.2e-218) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif ((B <= 6.2e-155) || !(B <= 1.5e-47)) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(A + B) / Float64(-B))))); else tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -1.5e-17) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -9.2e-218) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif ((B <= 6.2e-155) || ~((B <= 1.5e-47))) tmp = 180.0 / (pi / atan(((A + B) / -B))); else tmp = 180.0 / (pi / atan((0.5 * (B / A)))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -1.5e-17], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -9.2e-218], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[B, 6.2e-155], N[Not[LessEqual[B, 1.5e-47]], $MachinePrecision]], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(A + B), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -1.5 \cdot 10^{-17}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -9.2 \cdot 10^{-218}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 6.2 \cdot 10^{-155} \lor \neg \left(B \leq 1.5 \cdot 10^{-47}\right):\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{A + B}{-B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\end{array}
\end{array}
if B < -1.50000000000000003e-17Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -1.50000000000000003e-17 < B < -9.19999999999999979e-218Initial program 34.7%
Applied egg-rr57.7%
Taylor expanded in C around inf 47.9%
distribute-rgt1-in47.9%
metadata-eval47.9%
mul0-lft47.9%
div047.9%
metadata-eval47.9%
metadata-eval47.9%
cancel-sign-sub-inv47.9%
neg-sub047.9%
distribute-lft-neg-in47.9%
metadata-eval47.9%
associate-*r/47.9%
*-commutative47.9%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in B around 0 47.8%
associate-*r/47.8%
associate-*r/47.8%
*-commutative47.8%
associate-*r/47.8%
associate-*l/47.9%
Simplified47.9%
if -9.19999999999999979e-218 < B < 6.2e-155 or 1.50000000000000008e-47 < B Initial program 59.3%
Applied egg-rr80.2%
Taylor expanded in C around 0 52.6%
mul-1-neg52.6%
distribute-neg-frac252.6%
unpow252.6%
unpow252.6%
hypot-define68.6%
Simplified68.6%
Taylor expanded in A around 0 61.6%
if 6.2e-155 < B < 1.50000000000000008e-47Initial program 50.0%
Applied egg-rr64.5%
Taylor expanded in A around -inf 58.3%
Final simplification61.4%
(FPCore (A B C)
:precision binary64
(if (<= B -2.1e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -1.9e-217)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 1.7e-227)
(/ (* 180.0 (atan (/ (* A -2.0) B))) PI)
(if (<= B 3.3e-21)
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.1e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -1.9e-217) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 1.7e-227) {
tmp = (180.0 * atan(((A * -2.0) / B))) / ((double) M_PI);
} else if (B <= 3.3e-21) {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.1e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -1.9e-217) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 1.7e-227) {
tmp = (180.0 * Math.atan(((A * -2.0) / B))) / Math.PI;
} else if (B <= 3.3e-21) {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.1e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -1.9e-217: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 1.7e-227: tmp = (180.0 * math.atan(((A * -2.0) / B))) / math.pi elif B <= 3.3e-21: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.1e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -1.9e-217) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 1.7e-227) tmp = Float64(Float64(180.0 * atan(Float64(Float64(A * -2.0) / B))) / pi); elseif (B <= 3.3e-21) tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.1e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -1.9e-217) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 1.7e-227) tmp = (180.0 * atan(((A * -2.0) / B))) / pi; elseif (B <= 3.3e-21) tmp = 180.0 / (pi / atan((0.5 * (B / A)))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.1e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.9e-217], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.7e-227], N[(N[(180.0 * N[ArcTan[N[(N[(A * -2.0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 3.3e-21], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.1 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -1.9 \cdot 10^{-217}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 1.7 \cdot 10^{-227}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{A \cdot -2}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 3.3 \cdot 10^{-21}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.1e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -2.1e-18 < B < -1.89999999999999993e-217Initial program 34.7%
Applied egg-rr57.7%
Taylor expanded in C around inf 47.9%
distribute-rgt1-in47.9%
metadata-eval47.9%
mul0-lft47.9%
div047.9%
metadata-eval47.9%
metadata-eval47.9%
cancel-sign-sub-inv47.9%
neg-sub047.9%
distribute-lft-neg-in47.9%
metadata-eval47.9%
associate-*r/47.9%
*-commutative47.9%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in B around 0 47.8%
associate-*r/47.8%
associate-*r/47.8%
*-commutative47.8%
associate-*r/47.8%
associate-*l/47.9%
Simplified47.9%
if -1.89999999999999993e-217 < B < 1.69999999999999989e-227Initial program 70.9%
associate-*r/70.9%
associate-*l/70.9%
*-un-lft-identity70.9%
unpow270.9%
unpow270.9%
hypot-define81.7%
Applied egg-rr81.7%
Taylor expanded in A around inf 57.0%
*-commutative57.0%
Simplified57.0%
if 1.69999999999999989e-227 < B < 3.30000000000000009e-21Initial program 51.5%
Applied egg-rr71.0%
Taylor expanded in A around -inf 46.6%
if 3.30000000000000009e-21 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
(FPCore (A B C)
:precision binary64
(if (<= B -3.2e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -8.3e-215)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 9.6e-228)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 2.25e-21)
(/ 180.0 (/ PI (atan (* 0.5 (/ B A)))))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -3.2e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -8.3e-215) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 9.6e-228) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 2.25e-21) {
tmp = 180.0 / (((double) M_PI) / atan((0.5 * (B / A))));
} 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.2e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -8.3e-215) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 9.6e-228) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 2.25e-21) {
tmp = 180.0 / (Math.PI / Math.atan((0.5 * (B / A))));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -3.2e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -8.3e-215: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 9.6e-228: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 2.25e-21: tmp = 180.0 / (math.pi / math.atan((0.5 * (B / A)))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -3.2e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -8.3e-215) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 9.6e-228) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 2.25e-21) tmp = Float64(180.0 / Float64(pi / atan(Float64(0.5 * Float64(B / A))))); 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.2e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -8.3e-215) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 9.6e-228) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 2.25e-21) tmp = 180.0 / (pi / atan((0.5 * (B / A)))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -3.2e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -8.3e-215], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 9.6e-228], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.25e-21], N[(180.0 / N[(Pi / N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -3.2 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -8.3 \cdot 10^{-215}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 9.6 \cdot 10^{-228}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.25 \cdot 10^{-21}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -3.1999999999999999e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -3.1999999999999999e-18 < B < -8.3000000000000004e-215Initial program 34.7%
Applied egg-rr57.7%
Taylor expanded in C around inf 47.9%
distribute-rgt1-in47.9%
metadata-eval47.9%
mul0-lft47.9%
div047.9%
metadata-eval47.9%
metadata-eval47.9%
cancel-sign-sub-inv47.9%
neg-sub047.9%
distribute-lft-neg-in47.9%
metadata-eval47.9%
associate-*r/47.9%
*-commutative47.9%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in B around 0 47.8%
associate-*r/47.8%
associate-*r/47.8%
*-commutative47.8%
associate-*r/47.8%
associate-*l/47.9%
Simplified47.9%
if -8.3000000000000004e-215 < B < 9.60000000000000008e-228Initial program 70.9%
Taylor expanded in A around inf 57.0%
if 9.60000000000000008e-228 < B < 2.24999999999999984e-21Initial program 51.5%
Applied egg-rr71.0%
Taylor expanded in A around -inf 46.6%
if 2.24999999999999984e-21 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
Final simplification58.4%
(FPCore (A B C)
:precision binary64
(if (<= B -2.9e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -2.95e-217)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 1.75e-227)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 1.65e-20)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -2.95e-217) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 1.75e-227) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 1.65e-20) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -2.95e-217) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 1.75e-227) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 1.65e-20) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.9e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -2.95e-217: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 1.75e-227: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 1.65e-20: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.9e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -2.95e-217) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 1.75e-227) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 1.65e-20) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.9e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -2.95e-217) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 1.75e-227) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 1.65e-20) tmp = (180.0 / pi) * atan((0.5 * (B / A))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.9e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2.95e-217], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.75e-227], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.65e-20], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.9 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -2.95 \cdot 10^{-217}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 1.75 \cdot 10^{-227}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.65 \cdot 10^{-20}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.9e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -2.9e-18 < B < -2.9499999999999999e-217Initial program 34.7%
Applied egg-rr57.7%
Taylor expanded in C around inf 47.9%
distribute-rgt1-in47.9%
metadata-eval47.9%
mul0-lft47.9%
div047.9%
metadata-eval47.9%
metadata-eval47.9%
cancel-sign-sub-inv47.9%
neg-sub047.9%
distribute-lft-neg-in47.9%
metadata-eval47.9%
associate-*r/47.9%
*-commutative47.9%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in B around 0 47.8%
associate-*r/47.8%
associate-*r/47.8%
*-commutative47.8%
associate-*r/47.8%
associate-*l/47.9%
Simplified47.9%
if -2.9499999999999999e-217 < B < 1.75000000000000005e-227Initial program 70.9%
Taylor expanded in A around inf 57.0%
if 1.75000000000000005e-227 < B < 1.65e-20Initial program 51.5%
Taylor expanded in A around -inf 46.6%
associate-*r/46.6%
Simplified46.6%
Taylor expanded in B around 0 46.6%
associate-*r/46.6%
*-commutative46.6%
associate-/l*46.6%
Simplified46.6%
if 1.65e-20 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
Final simplification58.4%
(FPCore (A B C)
:precision binary64
(if (<= B -9.2e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -6.8e-217)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 1.1e-227)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 2.7e-21)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -9.2e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -6.8e-217) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 1.1e-227) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 2.7e-21) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} 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 <= -9.2e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -6.8e-217) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 1.1e-227) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 2.7e-21) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -9.2e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -6.8e-217: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 1.1e-227: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 2.7e-21: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -9.2e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -6.8e-217) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 1.1e-227) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 2.7e-21) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); 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 <= -9.2e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -6.8e-217) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 1.1e-227) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 2.7e-21) tmp = (180.0 / pi) * atan((0.5 * (B / A))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -9.2e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -6.8e-217], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.1e-227], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.7e-21], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -9.2 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -6.8 \cdot 10^{-217}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 1.1 \cdot 10^{-227}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.7 \cdot 10^{-21}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -9.2000000000000004e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -9.2000000000000004e-18 < B < -6.80000000000000032e-217Initial program 34.7%
Taylor expanded in C around inf 47.8%
Taylor expanded in A around inf 47.8%
Simplified47.9%
if -6.80000000000000032e-217 < B < 1.0999999999999999e-227Initial program 70.9%
Taylor expanded in A around inf 57.0%
if 1.0999999999999999e-227 < B < 2.7000000000000001e-21Initial program 51.5%
Taylor expanded in A around -inf 46.6%
associate-*r/46.6%
Simplified46.6%
Taylor expanded in B around 0 46.6%
associate-*r/46.6%
*-commutative46.6%
associate-/l*46.6%
Simplified46.6%
if 2.7000000000000001e-21 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
Final simplification58.4%
(FPCore (A B C)
:precision binary64
(if (<= B -2.9e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -6e-215)
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
(if (<= B 4.9e-228)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 1.9e-20)
(* (/ 180.0 PI) (atan (* 0.5 (/ B A))))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -6e-215) {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
} else if (B <= 4.9e-228) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 1.9e-20) {
tmp = (180.0 / ((double) M_PI)) * atan((0.5 * (B / A)));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -6e-215) {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
} else if (B <= 4.9e-228) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 1.9e-20) {
tmp = (180.0 / Math.PI) * Math.atan((0.5 * (B / A)));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.9e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -6e-215: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) elif B <= 4.9e-228: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 1.9e-20: tmp = (180.0 / math.pi) * math.atan((0.5 * (B / A))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.9e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -6e-215) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); elseif (B <= 4.9e-228) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 1.9e-20) tmp = Float64(Float64(180.0 / pi) * atan(Float64(0.5 * Float64(B / A)))); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.9e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -6e-215) tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); elseif (B <= 4.9e-228) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 1.9e-20) tmp = (180.0 / pi) * atan((0.5 * (B / A))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.9e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -6e-215], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 4.9e-228], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.9e-20], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.9 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -6 \cdot 10^{-215}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{elif}\;B \leq 4.9 \cdot 10^{-228}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.9 \cdot 10^{-20}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -2.9e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -2.9e-18 < B < -6.00000000000000051e-215Initial program 34.7%
Taylor expanded in C around inf 47.8%
Taylor expanded in A around inf 47.8%
if -6.00000000000000051e-215 < B < 4.89999999999999988e-228Initial program 70.9%
Taylor expanded in A around inf 57.0%
if 4.89999999999999988e-228 < B < 1.8999999999999999e-20Initial program 51.5%
Taylor expanded in A around -inf 46.6%
associate-*r/46.6%
Simplified46.6%
Taylor expanded in B around 0 46.6%
associate-*r/46.6%
*-commutative46.6%
associate-/l*46.6%
Simplified46.6%
if 1.8999999999999999e-20 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
Final simplification58.4%
(FPCore (A B C)
:precision binary64
(if (<= B -3.6e-18)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -7.6e-217)
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
(if (<= B 6.2e-228)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(if (<= B 1.62e-21)
(* 180.0 (/ (atan (* B (/ 0.5 A))) PI))
(* 180.0 (/ (atan -1.0) PI)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -3.6e-18) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -7.6e-217) {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
} else if (B <= 6.2e-228) {
tmp = 180.0 * (atan(((A / B) * -2.0)) / ((double) M_PI));
} else if (B <= 1.62e-21) {
tmp = 180.0 * (atan((B * (0.5 / A))) / ((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.6e-18) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -7.6e-217) {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
} else if (B <= 6.2e-228) {
tmp = 180.0 * (Math.atan(((A / B) * -2.0)) / Math.PI);
} else if (B <= 1.62e-21) {
tmp = 180.0 * (Math.atan((B * (0.5 / A))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -3.6e-18: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -7.6e-217: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) elif B <= 6.2e-228: tmp = 180.0 * (math.atan(((A / B) * -2.0)) / math.pi) elif B <= 1.62e-21: tmp = 180.0 * (math.atan((B * (0.5 / A))) / 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.6e-18) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -7.6e-217) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); elseif (B <= 6.2e-228) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); elseif (B <= 1.62e-21) tmp = Float64(180.0 * Float64(atan(Float64(B * Float64(0.5 / A))) / 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.6e-18) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -7.6e-217) tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); elseif (B <= 6.2e-228) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); elseif (B <= 1.62e-21) tmp = 180.0 * (atan((B * (0.5 / A))) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -3.6e-18], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -7.6e-217], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 6.2e-228], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.62e-21], N[(180.0 * N[(N[ArcTan[N[(B * N[(0.5 / A), $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 -3.6 \cdot 10^{-18}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -7.6 \cdot 10^{-217}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{elif}\;B \leq 6.2 \cdot 10^{-228}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{elif}\;B \leq 1.62 \cdot 10^{-21}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(B \cdot \frac{0.5}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -3.6000000000000001e-18Initial program 41.9%
Taylor expanded in B around -inf 68.2%
if -3.6000000000000001e-18 < B < -7.59999999999999974e-217Initial program 34.7%
Taylor expanded in C around inf 47.8%
Taylor expanded in A around inf 47.8%
if -7.59999999999999974e-217 < B < 6.1999999999999996e-228Initial program 70.9%
Taylor expanded in A around inf 57.0%
if 6.1999999999999996e-228 < B < 1.62000000000000003e-21Initial program 51.5%
Taylor expanded in A around -inf 46.6%
associate-*r/46.6%
Simplified46.6%
add-cube-cbrt46.2%
pow346.2%
associate-/l*46.2%
Applied egg-rr46.2%
Taylor expanded in B around 0 46.6%
associate-*r/46.6%
*-commutative46.6%
associate-/l*46.6%
Simplified46.6%
if 1.62000000000000003e-21 < B Initial program 55.1%
Taylor expanded in B around inf 60.8%
Final simplification58.4%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (- 1.0 (/ (- A C) B))) PI))))
(if (<= B -8.5e-32)
t_0
(if (<= B -2.35e-213)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= B 2.4e-16) t_0 (/ 180.0 (/ PI (atan (/ (+ A B) (- B))))))))))
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 <= -8.5e-32) {
tmp = t_0;
} else if (B <= -2.35e-213) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (B <= 2.4e-16) {
tmp = t_0;
} else {
tmp = 180.0 / (((double) M_PI) / atan(((A + B) / -B)));
}
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 <= -8.5e-32) {
tmp = t_0;
} else if (B <= -2.35e-213) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (B <= 2.4e-16) {
tmp = t_0;
} else {
tmp = 180.0 / (Math.PI / Math.atan(((A + B) / -B)));
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan((1.0 - ((A - C) / B))) / math.pi) tmp = 0 if B <= -8.5e-32: tmp = t_0 elif B <= -2.35e-213: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif B <= 2.4e-16: tmp = t_0 else: tmp = 180.0 / (math.pi / math.atan(((A + B) / -B))) 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 <= -8.5e-32) tmp = t_0; elseif (B <= -2.35e-213) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (B <= 2.4e-16) tmp = t_0; else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(A + B) / Float64(-B))))); 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 <= -8.5e-32) tmp = t_0; elseif (B <= -2.35e-213) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (B <= 2.4e-16) tmp = t_0; else tmp = 180.0 / (pi / atan(((A + B) / -B))); 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, -8.5e-32], t$95$0, If[LessEqual[B, -2.35e-213], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.4e-16], t$95$0, N[(180.0 / N[(Pi / N[ArcTan[N[(N[(A + B), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $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.5 \cdot 10^{-32}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq -2.35 \cdot 10^{-213}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;B \leq 2.4 \cdot 10^{-16}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{A + B}{-B}\right)}}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32 or -2.35e-213 < B < 2.40000000000000005e-16Initial program 52.4%
Taylor expanded in B around -inf 68.7%
associate--l+68.7%
div-sub68.7%
Simplified68.7%
if -8.5000000000000003e-32 < B < -2.35e-213Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if 2.40000000000000005e-16 < B Initial program 53.7%
Applied egg-rr79.6%
Taylor expanded in C around 0 49.9%
mul-1-neg49.9%
distribute-neg-frac249.9%
unpow249.9%
unpow249.9%
hypot-define70.2%
Simplified70.2%
Taylor expanded in A around 0 69.6%
Final simplification65.9%
(FPCore (A B C)
:precision binary64
(if (<= B -8.5e-32)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -1.15e-230)
(/ (* 180.0 (atan (/ 0.0 B))) PI)
(if (<= B 5.8e-20)
(* 180.0 (/ (atan (* (/ A B) -2.0)) PI))
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -8.5e-32) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -1.15e-230) {
tmp = (180.0 * atan((0.0 / B))) / ((double) M_PI);
} else if (B <= 5.8e-20) {
tmp = 180.0 * (atan(((A / B) * -2.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.5e-32) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -1.15e-230) {
tmp = (180.0 * Math.atan((0.0 / B))) / Math.PI;
} else if (B <= 5.8e-20) {
tmp = 180.0 * (Math.atan(((A / B) * -2.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.5e-32: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -1.15e-230: tmp = (180.0 * math.atan((0.0 / B))) / math.pi elif B <= 5.8e-20: tmp = 180.0 * (math.atan(((A / B) * -2.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.5e-32) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -1.15e-230) tmp = Float64(Float64(180.0 * atan(Float64(0.0 / B))) / pi); elseif (B <= 5.8e-20) tmp = Float64(180.0 * Float64(atan(Float64(Float64(A / B) * -2.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -8.5e-32) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -1.15e-230) tmp = (180.0 * atan((0.0 / B))) / pi; elseif (B <= 5.8e-20) tmp = 180.0 * (atan(((A / B) * -2.0)) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -8.5e-32], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.15e-230], N[(N[(180.0 * N[ArcTan[N[(0.0 / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 5.8e-20], N[(180.0 * N[(N[ArcTan[N[(N[(A / B), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -8.5 \cdot 10^{-32}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -1.15 \cdot 10^{-230}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 5.8 \cdot 10^{-20}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A}{B} \cdot -2\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
Taylor expanded in B around -inf 66.9%
if -8.5000000000000003e-32 < B < -1.1499999999999999e-230Initial program 34.7%
associate-*r/34.7%
associate-*l/34.7%
*-un-lft-identity34.7%
unpow234.7%
unpow234.7%
hypot-define57.7%
Applied egg-rr57.7%
Taylor expanded in C around inf 32.8%
distribute-rgt1-in32.8%
metadata-eval32.8%
mul0-lft32.8%
metadata-eval32.8%
Simplified32.8%
if -1.1499999999999999e-230 < B < 5.8e-20Initial program 59.9%
Taylor expanded in A around inf 41.0%
if 5.8e-20 < B Initial program 54.4%
Taylor expanded in B around inf 61.5%
Final simplification53.1%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ (- A C) B)))
(if (<= B -8.5e-32)
(* 180.0 (/ (atan (- 1.0 t_0)) PI))
(if (<= B -2.45e-216)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(* 180.0 (/ (atan (- -1.0 t_0)) PI))))))
double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = 180.0 * (atan((1.0 - t_0)) / ((double) M_PI));
} else if (B <= -2.45e-216) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else {
tmp = 180.0 * (atan((-1.0 - t_0)) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (A - C) / B;
double tmp;
if (B <= -8.5e-32) {
tmp = 180.0 * (Math.atan((1.0 - t_0)) / Math.PI);
} else if (B <= -2.45e-216) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else {
tmp = 180.0 * (Math.atan((-1.0 - t_0)) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = (A - C) / B tmp = 0 if B <= -8.5e-32: tmp = 180.0 * (math.atan((1.0 - t_0)) / math.pi) elif B <= -2.45e-216: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) else: tmp = 180.0 * (math.atan((-1.0 - t_0)) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(Float64(A - C) / B) tmp = 0.0 if (B <= -8.5e-32) tmp = Float64(180.0 * Float64(atan(Float64(1.0 - t_0)) / pi)); elseif (B <= -2.45e-216) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); else tmp = Float64(180.0 * Float64(atan(Float64(-1.0 - t_0)) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (A - C) / B; tmp = 0.0; if (B <= -8.5e-32) tmp = 180.0 * (atan((1.0 - t_0)) / pi); elseif (B <= -2.45e-216) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); else tmp = 180.0 * (atan((-1.0 - t_0)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(A - C), $MachinePrecision] / B), $MachinePrecision]}, If[LessEqual[B, -8.5e-32], N[(180.0 * N[(N[ArcTan[N[(1.0 - t$95$0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -2.45e-216], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-1.0 - t$95$0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{A - C}{B}\\
\mathbf{if}\;B \leq -8.5 \cdot 10^{-32}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 - t\_0\right)}{\pi}\\
\mathbf{elif}\;B \leq -2.45 \cdot 10^{-216}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-1 - t\_0\right)}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
Taylor expanded in B around -inf 81.4%
associate--l+81.4%
div-sub81.4%
Simplified81.4%
if -8.5000000000000003e-32 < B < -2.4500000000000001e-216Initial program 30.7%
Applied egg-rr55.2%
Taylor expanded in C around inf 44.8%
distribute-rgt1-in44.8%
metadata-eval44.8%
mul0-lft44.8%
div044.8%
metadata-eval44.8%
metadata-eval44.8%
cancel-sign-sub-inv44.8%
neg-sub044.8%
distribute-lft-neg-in44.8%
metadata-eval44.8%
associate-*r/44.8%
*-commutative44.8%
associate-/l*44.7%
Simplified44.7%
Taylor expanded in B around 0 44.6%
associate-*r/44.7%
associate-*r/44.7%
*-commutative44.7%
associate-*r/44.6%
associate-*l/44.8%
Simplified44.8%
if -2.4500000000000001e-216 < B Initial program 58.0%
+-commutative58.0%
unpow258.0%
unpow258.0%
hypot-undefine77.9%
sub-neg77.9%
distribute-lft-in68.2%
hypot-undefine55.7%
unpow255.7%
unpow255.7%
+-commutative55.7%
unpow255.7%
unpow255.7%
hypot-define68.2%
Applied egg-rr68.2%
Taylor expanded in B around inf 66.6%
+-commutative66.6%
associate--r+66.6%
div-sub66.6%
sub-neg66.6%
metadata-eval66.6%
Simplified66.6%
Final simplification68.4%
(FPCore (A B C)
:precision binary64
(if (<= B -8.5e-32)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 1.7e-113)
(/ (* 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 <= -8.5e-32) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 1.7e-113) {
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 <= -8.5e-32) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 1.7e-113) {
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 <= -8.5e-32: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 1.7e-113: 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 <= -8.5e-32) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 1.7e-113) tmp = Float64(Float64(180.0 * 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 <= -8.5e-32) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 1.7e-113) 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, -8.5e-32], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.7e-113], N[(N[(180.0 * N[ArcTan[N[(0.0 / 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 -8.5 \cdot 10^{-32}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 1.7 \cdot 10^{-113}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
Taylor expanded in B around -inf 66.9%
if -8.5000000000000003e-32 < B < 1.7000000000000001e-113Initial program 49.4%
associate-*r/49.4%
associate-*l/49.4%
*-un-lft-identity49.4%
unpow249.4%
unpow249.4%
hypot-define70.3%
Applied egg-rr70.3%
Taylor expanded in C around inf 27.7%
distribute-rgt1-in27.7%
metadata-eval27.7%
mul0-lft27.7%
metadata-eval27.7%
Simplified27.7%
if 1.7000000000000001e-113 < B Initial program 56.6%
Taylor expanded in B around inf 49.7%
(FPCore (A B C)
:precision binary64
(if (<= B -8.5e-32)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 4.8e-113)
(* 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 <= -8.5e-32) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 4.8e-113) {
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 <= -8.5e-32) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 4.8e-113) {
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 <= -8.5e-32: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 4.8e-113: 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 <= -8.5e-32) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 4.8e-113) 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 <= -8.5e-32) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 4.8e-113) 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, -8.5e-32], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 4.8e-113], 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 -8.5 \cdot 10^{-32}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 4.8 \cdot 10^{-113}:\\
\;\;\;\;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 < -8.5000000000000003e-32Initial program 43.4%
Taylor expanded in B around -inf 66.9%
if -8.5000000000000003e-32 < B < 4.80000000000000024e-113Initial program 49.4%
Taylor expanded in C around inf 27.7%
associate-*r/27.7%
distribute-rgt1-in27.7%
metadata-eval27.7%
mul0-lft27.7%
metadata-eval27.7%
Simplified27.7%
if 4.80000000000000024e-113 < B Initial program 56.6%
Taylor expanded in B around inf 49.7%
(FPCore (A B C)
:precision binary64
(if (<= B -8.5e-32)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 3.9e-113)
(* 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.5e-32) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 3.9e-113) {
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.5e-32) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 3.9e-113) {
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.5e-32: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 3.9e-113: 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.5e-32) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 3.9e-113) tmp = Float64(180.0 * Float64(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.5e-32) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 3.9e-113) 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.5e-32], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 3.9e-113], N[(180.0 * N[(N[ArcTan[0.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 -8.5 \cdot 10^{-32}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 3.9 \cdot 10^{-113}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -8.5000000000000003e-32Initial program 43.4%
Taylor expanded in B around -inf 66.9%
if -8.5000000000000003e-32 < B < 3.8999999999999999e-113Initial program 49.4%
+-commutative49.4%
unpow249.4%
unpow249.4%
hypot-undefine70.3%
sub-neg70.3%
distribute-lft-in45.9%
hypot-undefine43.4%
unpow243.4%
unpow243.4%
+-commutative43.4%
unpow243.4%
unpow243.4%
hypot-define45.9%
Applied egg-rr45.9%
Taylor expanded in A around -inf 14.2%
distribute-lft1-in14.2%
metadata-eval14.2%
mul0-lft27.7%
Simplified27.7%
if 3.8999999999999999e-113 < B Initial program 56.6%
Taylor expanded in B around inf 49.7%
(FPCore (A B C) :precision binary64 (if (<= B 1.3e-113) (* 180.0 (/ (atan 0.0) PI)) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= 1.3e-113) {
tmp = 180.0 * (atan(0.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 1.3e-113) {
tmp = 180.0 * (Math.atan(0.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 1.3e-113: tmp = 180.0 * (math.atan(0.0) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 1.3e-113) tmp = Float64(180.0 * Float64(atan(0.0) / pi)); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 1.3e-113) tmp = 180.0 * (atan(0.0) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 1.3e-113], N[(180.0 * N[(N[ArcTan[0.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.3 \cdot 10^{-113}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < 1.3e-113Initial program 46.6%
+-commutative46.6%
unpow246.6%
unpow246.6%
hypot-undefine77.2%
sub-neg77.2%
distribute-lft-in64.0%
hypot-undefine43.3%
unpow243.3%
unpow243.3%
+-commutative43.3%
unpow243.3%
unpow243.3%
hypot-define64.0%
Applied egg-rr64.0%
Taylor expanded in A around -inf 9.3%
distribute-lft1-in9.3%
metadata-eval9.3%
mul0-lft16.5%
Simplified16.5%
if 1.3e-113 < B Initial program 56.6%
Taylor expanded in B around inf 49.7%
(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 50.0%
Taylor expanded in B around inf 20.0%
herbie shell --seed 2024103
(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)))