
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi}
\end{array}
(FPCore (A B C) :precision binary64 (if (<= A -1.95e+68) (/ (* 180.0 (atan (/ (* 0.5 (fma C (/ B A) B)) A))) PI) (/ 180.0 (/ PI (atan (/ (- (- C A) (hypot B (- A C))) B))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.95e+68) {
tmp = (180.0 * atan(((0.5 * fma(C, (B / A), B)) / A))) / ((double) M_PI);
} else {
tmp = 180.0 / (((double) M_PI) / atan((((C - A) - hypot(B, (A - C))) / B)));
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (A <= -1.95e+68) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(C, Float64(B / A), B)) / A))) / pi); else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)))); end return tmp end
code[A_, B_, C_] := If[LessEqual[A, -1.95e+68], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(C * N[(B / A), $MachinePrecision] + B), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.95 \cdot 10^{+68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(C, \frac{B}{A}, B\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}}\\
\end{array}
\end{array}
if A < -1.95000000000000009e68Initial program 13.5%
Taylor expanded in A around -inf 80.8%
associate-*r/80.8%
mul-1-neg80.8%
distribute-lft-out80.8%
*-commutative80.8%
Simplified80.8%
associate-*r/80.7%
distribute-lft-neg-in80.7%
metadata-eval80.7%
+-commutative80.7%
associate-/l*84.6%
fma-define84.6%
Applied egg-rr84.6%
if -1.95000000000000009e68 < A Initial program 69.0%
*-commutative69.0%
associate--l-68.1%
+-commutative68.1%
unpow268.1%
unpow268.1%
hypot-undefine84.8%
div-inv84.8%
clear-num84.8%
un-div-inv84.8%
Applied egg-rr85.7%
(FPCore (A B C)
:precision binary64
(if (<= A -1e+71)
(/ (* 180.0 (atan (/ (* 0.5 (fma C (/ B A) B)) A))) PI)
(if (<= A 1.3e-124)
(/ 180.0 (/ PI (atan (/ (- C (hypot C B)) B))))
(* (/ 180.0 PI) (atan (/ (+ A (hypot A B)) (- B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1e+71) {
tmp = (180.0 * atan(((0.5 * fma(C, (B / A), B)) / A))) / ((double) M_PI);
} else if (A <= 1.3e-124) {
tmp = 180.0 / (((double) M_PI) / atan(((C - hypot(C, B)) / B)));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((A + hypot(A, B)) / -B));
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (A <= -1e+71) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(C, Float64(B / A), B)) / A))) / pi); elseif (A <= 1.3e-124) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(C, B)) / B)))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(A + hypot(A, B)) / Float64(-B)))); end return tmp end
code[A_, B_, C_] := If[LessEqual[A, -1e+71], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(C * N[(B / A), $MachinePrecision] + B), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.3e-124], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1 \cdot 10^{+71}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(C, \frac{B}{A}, B\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.3 \cdot 10^{-124}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)\\
\end{array}
\end{array}
if A < -1e71Initial program 13.5%
Taylor expanded in A around -inf 80.8%
associate-*r/80.8%
mul-1-neg80.8%
distribute-lft-out80.8%
*-commutative80.8%
Simplified80.8%
associate-*r/80.7%
distribute-lft-neg-in80.7%
metadata-eval80.7%
+-commutative80.7%
associate-/l*84.6%
fma-define84.6%
Applied egg-rr84.6%
if -1e71 < A < 1.3e-124Initial program 62.5%
*-commutative62.5%
associate--l-60.9%
+-commutative60.9%
unpow260.9%
unpow260.9%
hypot-undefine78.8%
div-inv78.8%
clear-num78.9%
un-div-inv78.9%
Applied egg-rr80.5%
Taylor expanded in A around 0 60.2%
+-commutative60.2%
unpow260.2%
unpow260.2%
hypot-define79.0%
Simplified79.0%
if 1.3e-124 < A Initial program 77.4%
Taylor expanded in B around 0 77.4%
Simplified92.6%
Taylor expanded in C around 0 76.4%
mul-1-neg76.4%
unpow276.4%
unpow276.4%
hypot-define86.3%
Simplified86.3%
Final simplification82.6%
(FPCore (A B C)
:precision binary64
(if (<= A -5.5e+69)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 1.25e-124)
(/ 180.0 (/ PI (atan (/ (- C (hypot C B)) B))))
(* (/ 180.0 PI) (atan (/ (+ A (hypot A B)) (- B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -5.5e+69) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 1.25e-124) {
tmp = 180.0 / (((double) M_PI) / atan(((C - hypot(C, B)) / B)));
} 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 <= -5.5e+69) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 1.25e-124) {
tmp = 180.0 / (Math.PI / Math.atan(((C - Math.hypot(C, B)) / B)));
} 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 <= -5.5e+69: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 1.25e-124: tmp = 180.0 / (math.pi / math.atan(((C - math.hypot(C, B)) / B))) 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 <= -5.5e+69) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 1.25e-124) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(C, B)) / B)))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(A + hypot(A, B)) / Float64(-B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -5.5e+69) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 1.25e-124) tmp = 180.0 / (pi / atan(((C - hypot(C, B)) / B))); else tmp = (180.0 / pi) * atan(((A + hypot(A, B)) / -B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -5.5e+69], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.25e-124], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -5.5 \cdot 10^{+69}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 1.25 \cdot 10^{-124}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)\\
\end{array}
\end{array}
if A < -5.50000000000000002e69Initial program 13.5%
*-commutative13.5%
associate--l-11.3%
+-commutative11.3%
unpow211.3%
unpow211.3%
hypot-undefine18.1%
div-inv18.1%
clear-num18.1%
un-div-inv18.1%
Applied egg-rr50.5%
Taylor expanded in A around -inf 81.5%
associate-*r/81.5%
*-commutative81.5%
Simplified81.5%
if -5.50000000000000002e69 < A < 1.2500000000000001e-124Initial program 62.5%
*-commutative62.5%
associate--l-60.9%
+-commutative60.9%
unpow260.9%
unpow260.9%
hypot-undefine78.8%
div-inv78.8%
clear-num78.9%
un-div-inv78.9%
Applied egg-rr80.5%
Taylor expanded in A around 0 60.2%
+-commutative60.2%
unpow260.2%
unpow260.2%
hypot-define79.0%
Simplified79.0%
if 1.2500000000000001e-124 < A Initial program 77.4%
Taylor expanded in B around 0 77.4%
Simplified92.6%
Taylor expanded in C around 0 76.4%
mul-1-neg76.4%
unpow276.4%
unpow276.4%
hypot-define86.3%
Simplified86.3%
Final simplification82.1%
(FPCore (A B C)
:precision binary64
(if (<= A -5.7e+69)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 1.35e-124)
(/ 180.0 (/ PI (atan (/ (- C (hypot C B)) B))))
(* 180.0 (/ (atan (/ (+ A (hypot A B)) (- B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -5.7e+69) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 1.35e-124) {
tmp = 180.0 / (((double) M_PI) / atan(((C - hypot(C, B)) / B)));
} 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 <= -5.7e+69) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 1.35e-124) {
tmp = 180.0 / (Math.PI / Math.atan(((C - Math.hypot(C, B)) / B)));
} 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 <= -5.7e+69: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 1.35e-124: tmp = 180.0 / (math.pi / math.atan(((C - math.hypot(C, B)) / B))) 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 <= -5.7e+69) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 1.35e-124) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(C, B)) / B)))); else tmp = Float64(180.0 * Float64(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 <= -5.7e+69) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 1.35e-124) tmp = 180.0 / (pi / atan(((C - hypot(C, B)) / B))); else tmp = 180.0 * (atan(((A + hypot(A, B)) / -B)) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -5.7e+69], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.35e-124], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / (-B)), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -5.7 \cdot 10^{+69}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 1.35 \cdot 10^{-124}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{A + \mathsf{hypot}\left(A, B\right)}{-B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -5.7e69Initial program 13.5%
*-commutative13.5%
associate--l-11.3%
+-commutative11.3%
unpow211.3%
unpow211.3%
hypot-undefine18.1%
div-inv18.1%
clear-num18.1%
un-div-inv18.1%
Applied egg-rr50.5%
Taylor expanded in A around -inf 81.5%
associate-*r/81.5%
*-commutative81.5%
Simplified81.5%
if -5.7e69 < A < 1.35000000000000009e-124Initial program 62.5%
*-commutative62.5%
associate--l-60.9%
+-commutative60.9%
unpow260.9%
unpow260.9%
hypot-undefine78.8%
div-inv78.8%
clear-num78.9%
un-div-inv78.9%
Applied egg-rr80.5%
Taylor expanded in A around 0 60.2%
+-commutative60.2%
unpow260.2%
unpow260.2%
hypot-define79.0%
Simplified79.0%
if 1.35000000000000009e-124 < A Initial program 77.4%
Taylor expanded in C around 0 76.4%
associate-*r/76.4%
mul-1-neg76.4%
unpow276.4%
unpow276.4%
hypot-define86.3%
Simplified86.3%
Final simplification82.0%
(FPCore (A B C)
:precision binary64
(if (<= A -9e+69)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 6.5e+115)
(/ 180.0 (/ PI (atan (/ (- C (hypot C B)) B))))
(* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -9e+69) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 6.5e+115) {
tmp = 180.0 / (((double) M_PI) / atan(((C - hypot(C, B)) / B)));
} else {
tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -9e+69) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 6.5e+115) {
tmp = 180.0 / (Math.PI / Math.atan(((C - Math.hypot(C, B)) / B)));
} else {
tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -9e+69: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 6.5e+115: tmp = 180.0 / (math.pi / math.atan(((C - math.hypot(C, B)) / B))) else: tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -9e+69) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 6.5e+115) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - hypot(C, B)) / B)))); else tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -9e+69) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 6.5e+115) tmp = 180.0 / (pi / atan(((C - hypot(C, B)) / B))); else tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -9e+69], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 6.5e+115], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -9 \cdot 10^{+69}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 6.5 \cdot 10^{+115}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -8.9999999999999999e69Initial program 13.5%
*-commutative13.5%
associate--l-11.3%
+-commutative11.3%
unpow211.3%
unpow211.3%
hypot-undefine18.1%
div-inv18.1%
clear-num18.1%
un-div-inv18.1%
Applied egg-rr50.5%
Taylor expanded in A around -inf 81.5%
associate-*r/81.5%
*-commutative81.5%
Simplified81.5%
if -8.9999999999999999e69 < A < 6.49999999999999966e115Initial program 62.5%
*-commutative62.5%
associate--l-61.4%
+-commutative61.4%
unpow261.4%
unpow261.4%
hypot-undefine81.7%
div-inv81.7%
clear-num81.8%
un-div-inv81.8%
Applied egg-rr83.0%
Taylor expanded in A around 0 56.4%
+-commutative56.4%
unpow256.4%
unpow256.4%
hypot-define77.5%
Simplified77.5%
if 6.49999999999999966e115 < A Initial program 92.2%
Taylor expanded in B around -inf 85.1%
associate--l+85.1%
div-sub94.0%
Simplified94.0%
Final simplification81.1%
(FPCore (A B C)
:precision binary64
(if (<= A -2.05e+67)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 6.5e+115)
(* (atan (/ (- C (hypot C B)) B)) (/ 180.0 PI))
(* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -2.05e+67) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 6.5e+115) {
tmp = atan(((C - hypot(C, B)) / B)) * (180.0 / ((double) M_PI));
} else {
tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -2.05e+67) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 6.5e+115) {
tmp = Math.atan(((C - Math.hypot(C, B)) / B)) * (180.0 / Math.PI);
} else {
tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -2.05e+67: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 6.5e+115: tmp = math.atan(((C - math.hypot(C, B)) / B)) * (180.0 / math.pi) else: tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -2.05e+67) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 6.5e+115) tmp = Float64(atan(Float64(Float64(C - hypot(C, B)) / B)) * Float64(180.0 / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -2.05e+67) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 6.5e+115) tmp = atan(((C - hypot(C, B)) / B)) * (180.0 / pi); else tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -2.05e+67], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 6.5e+115], N[(N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -2.05 \cdot 10^{+67}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 6.5 \cdot 10^{+115}:\\
\;\;\;\;\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right) \cdot \frac{180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -2.0499999999999999e67Initial program 13.5%
*-commutative13.5%
associate--l-11.3%
+-commutative11.3%
unpow211.3%
unpow211.3%
hypot-undefine18.1%
div-inv18.1%
clear-num18.1%
un-div-inv18.1%
Applied egg-rr50.5%
Taylor expanded in A around -inf 81.5%
associate-*r/81.5%
*-commutative81.5%
Simplified81.5%
if -2.0499999999999999e67 < A < 6.49999999999999966e115Initial program 62.5%
Taylor expanded in B around 0 61.4%
Simplified81.8%
Taylor expanded in A around 0 56.4%
+-commutative56.4%
unpow256.4%
unpow256.4%
hypot-define77.5%
Simplified77.5%
if 6.49999999999999966e115 < A Initial program 92.2%
Taylor expanded in B around -inf 85.1%
associate--l+85.1%
div-sub94.0%
Simplified94.0%
Final simplification81.1%
(FPCore (A B C)
:precision binary64
(if (<= A -3.8e+69)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 7.5e+115)
(* 180.0 (/ (atan (/ (- C (hypot C B)) B)) PI))
(* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.8e+69) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 7.5e+115) {
tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.8e+69) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 7.5e+115) {
tmp = 180.0 * (Math.atan(((C - Math.hypot(C, B)) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.8e+69: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 7.5e+115: tmp = 180.0 * (math.atan(((C - math.hypot(C, B)) / B)) / math.pi) else: tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.8e+69) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 7.5e+115) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - hypot(C, B)) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.8e+69) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 7.5e+115) tmp = 180.0 * (atan(((C - hypot(C, B)) / B)) / pi); else tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.8e+69], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 7.5e+115], N[(180.0 * N[(N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3.8 \cdot 10^{+69}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 7.5 \cdot 10^{+115}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.80000000000000028e69Initial program 13.5%
*-commutative13.5%
associate--l-11.3%
+-commutative11.3%
unpow211.3%
unpow211.3%
hypot-undefine18.1%
div-inv18.1%
clear-num18.1%
un-div-inv18.1%
Applied egg-rr50.5%
Taylor expanded in A around -inf 81.5%
associate-*r/81.5%
*-commutative81.5%
Simplified81.5%
if -3.80000000000000028e69 < A < 7.4999999999999997e115Initial program 62.5%
Taylor expanded in A around 0 56.4%
+-commutative56.4%
unpow256.4%
unpow256.4%
hypot-define77.4%
Simplified77.4%
if 7.4999999999999997e115 < A Initial program 92.2%
Taylor expanded in B around -inf 85.1%
associate--l+85.1%
div-sub94.0%
Simplified94.0%
Final simplification81.1%
(FPCore (A B C) :precision binary64 (if (<= A -1.32e+68) (/ (* 180.0 (atan (/ (* 0.5 (fma C (/ B A) B)) 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.32e+68) {
tmp = (180.0 * atan(((0.5 * fma(C, (B / A), B)) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((((C - A) - hypot(B, (A - C))) / B)) / ((double) M_PI));
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (A <= -1.32e+68) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(C, Float64(B / A), B)) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C - A) - hypot(B, Float64(A - C))) / B)) / pi)); end return tmp end
code[A_, B_, C_] := If[LessEqual[A, -1.32e+68], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(C * N[(B / A), $MachinePrecision] + B), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.32 \cdot 10^{+68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(C, \frac{B}{A}, B\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(B, A - C\right)}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.3200000000000001e68Initial program 13.5%
Taylor expanded in A around -inf 80.8%
associate-*r/80.8%
mul-1-neg80.8%
distribute-lft-out80.8%
*-commutative80.8%
Simplified80.8%
associate-*r/80.7%
distribute-lft-neg-in80.7%
metadata-eval80.7%
+-commutative80.7%
associate-/l*84.6%
fma-define84.6%
Applied egg-rr84.6%
if -1.3200000000000001e68 < A Initial program 69.0%
associate-*l/69.0%
*-lft-identity69.0%
+-commutative69.0%
unpow269.0%
unpow269.0%
hypot-define85.7%
Simplified85.7%
(FPCore (A B C) :precision binary64 (if (<= A -6.4e+68) (/ (* 180.0 (atan (/ (* 0.5 (fma C (/ B A) B)) 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 <= -6.4e+68) {
tmp = (180.0 * atan(((0.5 * fma(C, (B / A), B)) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((C - (A + hypot(B, (A - C)))) / B)) / ((double) M_PI));
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (A <= -6.4e+68) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(C, Float64(B / A), B)) / 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
code[A_, B_, C_] := If[LessEqual[A, -6.4e+68], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(C * N[(B / A), $MachinePrecision] + B), $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 -6.4 \cdot 10^{+68}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(C, \frac{B}{A}, B\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 < -6.39999999999999989e68Initial program 13.5%
Taylor expanded in A around -inf 80.8%
associate-*r/80.8%
mul-1-neg80.8%
distribute-lft-out80.8%
*-commutative80.8%
Simplified80.8%
associate-*r/80.7%
distribute-lft-neg-in80.7%
metadata-eval80.7%
+-commutative80.7%
associate-/l*84.6%
fma-define84.6%
Applied egg-rr84.6%
if -6.39999999999999989e68 < A Initial program 69.0%
Simplified84.8%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (/ 180.0 (/ PI (atan (/ (- C B) B))))))
(if (<= A -1.15e+35)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A -1.8e-55)
t_0
(if (<= A -4e-229)
(* (/ 180.0 PI) (atan (+ 1.0 (/ C B))))
(if (<= A 1.02e+74) t_0 (* 180.0 (/ (atan (* A (/ -2.0 B))) PI))))))))
double code(double A, double B, double C) {
double t_0 = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
double tmp;
if (A <= -1.15e+35) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= -1.8e-55) {
tmp = t_0;
} else if (A <= -4e-229) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + (C / B)));
} else if (A <= 1.02e+74) {
tmp = t_0;
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
double tmp;
if (A <= -1.15e+35) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= -1.8e-55) {
tmp = t_0;
} else if (A <= -4e-229) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + (C / B)));
} else if (A <= 1.02e+74) {
tmp = t_0;
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 / (math.pi / math.atan(((C - B) / B))) tmp = 0 if A <= -1.15e+35: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= -1.8e-55: tmp = t_0 elif A <= -4e-229: tmp = (180.0 / math.pi) * math.atan((1.0 + (C / B))) elif A <= 1.02e+74: tmp = t_0 else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) t_0 = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B)))) tmp = 0.0 if (A <= -1.15e+35) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= -1.8e-55) tmp = t_0; elseif (A <= -4e-229) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(C / B)))); elseif (A <= 1.02e+74) tmp = t_0; else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 / (pi / atan(((C - B) / B))); tmp = 0.0; if (A <= -1.15e+35) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= -1.8e-55) tmp = t_0; elseif (A <= -4e-229) tmp = (180.0 / pi) * atan((1.0 + (C / B))); elseif (A <= 1.02e+74) tmp = t_0; else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -1.15e+35], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1.8e-55], t$95$0, If[LessEqual[A, -4e-229], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.02e+74], t$95$0, N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\
\mathbf{if}\;A \leq -1.15 \cdot 10^{+35}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq -1.8 \cdot 10^{-55}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;A \leq -4 \cdot 10^{-229}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)\\
\mathbf{elif}\;A \leq 1.02 \cdot 10^{+74}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.1499999999999999e35Initial program 20.9%
*-commutative20.9%
associate--l-15.5%
+-commutative15.5%
unpow215.5%
unpow215.5%
hypot-undefine22.8%
div-inv22.8%
clear-num22.8%
un-div-inv22.8%
Applied egg-rr54.1%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
*-commutative76.6%
Simplified76.6%
if -1.1499999999999999e35 < A < -1.8e-55 or -4.00000000000000028e-229 < A < 1.02000000000000005e74Initial program 66.3%
*-commutative66.3%
associate--l-66.3%
+-commutative66.3%
unpow266.3%
unpow266.3%
hypot-undefine83.9%
div-inv83.9%
clear-num84.0%
un-div-inv84.0%
Applied egg-rr83.9%
Taylor expanded in A around 0 61.0%
+-commutative61.0%
unpow261.0%
unpow261.0%
hypot-define78.8%
Simplified78.8%
Taylor expanded in C around 0 59.4%
if -1.8e-55 < A < -4.00000000000000028e-229Initial program 54.1%
Taylor expanded in B around 0 54.1%
Simplified78.5%
Taylor expanded in A around 0 53.3%
+-commutative53.3%
unpow253.3%
unpow253.3%
hypot-define77.7%
Simplified77.7%
Taylor expanded in B around -inf 57.9%
+-commutative57.9%
Simplified57.9%
if 1.02000000000000005e74 < A Initial program 86.4%
associate-*l/86.4%
*-lft-identity86.4%
+-commutative86.4%
unpow286.4%
unpow286.4%
hypot-define96.4%
Simplified96.4%
Taylor expanded in A around inf 81.4%
*-commutative81.4%
Simplified81.4%
Taylor expanded in A around 0 81.4%
associate-*r/81.4%
*-commutative81.4%
associate-*r/81.4%
Simplified81.4%
Final simplification67.5%
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* 180.0 (/ (atan (* -0.5 (/ B C))) PI))))
(if (<= B -1.15e+15)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -1.6e-198)
t_0
(if (<= B 8.5e-209)
(* 180.0 (/ (atan 0.0) PI))
(if (<= B 1.45e-18) 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 <= -1.15e+15) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -1.6e-198) {
tmp = t_0;
} else if (B <= 8.5e-209) {
tmp = 180.0 * (atan(0.0) / ((double) M_PI));
} else if (B <= 1.45e-18) {
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 <= -1.15e+15) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -1.6e-198) {
tmp = t_0;
} else if (B <= 8.5e-209) {
tmp = 180.0 * (Math.atan(0.0) / Math.PI);
} else if (B <= 1.45e-18) {
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 <= -1.15e+15: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -1.6e-198: tmp = t_0 elif B <= 8.5e-209: tmp = 180.0 * (math.atan(0.0) / math.pi) elif B <= 1.45e-18: 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 <= -1.15e+15) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -1.6e-198) tmp = t_0; elseif (B <= 8.5e-209) tmp = Float64(180.0 * Float64(atan(0.0) / pi)); elseif (B <= 1.45e-18) 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 <= -1.15e+15) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -1.6e-198) tmp = t_0; elseif (B <= 8.5e-209) tmp = 180.0 * (atan(0.0) / pi); elseif (B <= 1.45e-18) 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, -1.15e+15], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -1.6e-198], t$95$0, If[LessEqual[B, 8.5e-209], N[(180.0 * N[(N[ArcTan[0.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.45e-18], 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 -1.15 \cdot 10^{+15}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -1.6 \cdot 10^{-198}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;B \leq 8.5 \cdot 10^{-209}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{elif}\;B \leq 1.45 \cdot 10^{-18}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -1.15e15Initial program 52.4%
Taylor expanded in B around -inf 62.9%
if -1.15e15 < B < -1.59999999999999997e-198 or 8.5e-209 < B < 1.45e-18Initial program 53.0%
Taylor expanded in C around inf 38.1%
Taylor expanded in A around inf 38.1%
if -1.59999999999999997e-198 < B < 8.5e-209Initial program 69.7%
Taylor expanded in C around inf 25.1%
Taylor expanded in B around 0 41.2%
distribute-rgt1-in41.2%
metadata-eval41.2%
mul0-lft41.2%
div041.2%
metadata-eval41.2%
Simplified41.2%
if 1.45e-18 < B Initial program 61.2%
Taylor expanded in B around inf 52.3%
(FPCore (A B C)
:precision binary64
(if (<= A -5.2e+36)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A -1e-53)
(/ 180.0 (/ PI (atan (/ (- C B) B))))
(if (<= A -2.8e-228)
(* (/ 180.0 PI) (atan (+ 1.0 (/ C B))))
(/ 180.0 (/ PI (atan (+ (/ (- C A) B) -1.0))))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -5.2e+36) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= -1e-53) {
tmp = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
} else if (A <= -2.8e-228) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + (C / B)));
} else {
tmp = 180.0 / (((double) M_PI) / atan((((C - A) / B) + -1.0)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -5.2e+36) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= -1e-53) {
tmp = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
} else if (A <= -2.8e-228) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + (C / B)));
} else {
tmp = 180.0 / (Math.PI / Math.atan((((C - A) / B) + -1.0)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -5.2e+36: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= -1e-53: tmp = 180.0 / (math.pi / math.atan(((C - B) / B))) elif A <= -2.8e-228: tmp = (180.0 / math.pi) * math.atan((1.0 + (C / B))) else: tmp = 180.0 / (math.pi / math.atan((((C - A) / B) + -1.0))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -5.2e+36) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= -1e-53) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B)))); elseif (A <= -2.8e-228) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(C / B)))); else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C - A) / B) + -1.0)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -5.2e+36) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= -1e-53) tmp = 180.0 / (pi / atan(((C - B) / B))); elseif (A <= -2.8e-228) tmp = (180.0 / pi) * atan((1.0 + (C / B))); else tmp = 180.0 / (pi / atan((((C - A) / B) + -1.0))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -5.2e+36], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -1e-53], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.8e-228], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -5.2 \cdot 10^{+36}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq -1 \cdot 10^{-53}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\
\mathbf{elif}\;A \leq -2.8 \cdot 10^{-228}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - A}{B} + -1\right)}}\\
\end{array}
\end{array}
if A < -5.2000000000000003e36Initial program 20.9%
*-commutative20.9%
associate--l-15.5%
+-commutative15.5%
unpow215.5%
unpow215.5%
hypot-undefine22.8%
div-inv22.8%
clear-num22.8%
un-div-inv22.8%
Applied egg-rr54.1%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
*-commutative76.6%
Simplified76.6%
if -5.2000000000000003e36 < A < -1.00000000000000003e-53Initial program 53.7%
*-commutative53.7%
associate--l-54.1%
+-commutative54.1%
unpow254.1%
unpow254.1%
hypot-undefine64.5%
div-inv64.5%
clear-num64.5%
un-div-inv64.5%
Applied egg-rr64.1%
Taylor expanded in A around 0 53.8%
+-commutative53.8%
unpow253.8%
unpow253.8%
hypot-define64.1%
Simplified64.1%
Taylor expanded in C around 0 62.3%
if -1.00000000000000003e-53 < A < -2.8000000000000003e-228Initial program 54.1%
Taylor expanded in B around 0 54.1%
Simplified78.5%
Taylor expanded in A around 0 53.3%
+-commutative53.3%
unpow253.3%
unpow253.3%
hypot-define77.7%
Simplified77.7%
Taylor expanded in B around -inf 57.9%
+-commutative57.9%
Simplified57.9%
if -2.8000000000000003e-228 < A Initial program 75.5%
*-commutative75.5%
associate--l-75.5%
+-commutative75.5%
unpow275.5%
unpow275.5%
hypot-undefine91.1%
div-inv91.1%
clear-num91.2%
un-div-inv91.2%
Applied egg-rr91.2%
Taylor expanded in B around inf 68.8%
+-commutative68.8%
associate--r+68.8%
div-sub71.7%
Simplified71.7%
Final simplification69.9%
(FPCore (A B C)
:precision binary64
(if (<= A -7.6e+19)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= A -4.5e-162)
(* (/ 180.0 PI) (atan (* B (/ -0.5 C))))
(if (<= A 9.8e-123)
(* 180.0 (/ (atan (/ (* C 2.0) B)) PI))
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -7.6e+19) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (A <= -4.5e-162) {
tmp = (180.0 / ((double) M_PI)) * atan((B * (-0.5 / C)));
} else if (A <= 9.8e-123) {
tmp = 180.0 * (atan(((C * 2.0) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -7.6e+19) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (A <= -4.5e-162) {
tmp = (180.0 / Math.PI) * Math.atan((B * (-0.5 / C)));
} else if (A <= 9.8e-123) {
tmp = 180.0 * (Math.atan(((C * 2.0) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -7.6e+19: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif A <= -4.5e-162: tmp = (180.0 / math.pi) * math.atan((B * (-0.5 / C))) elif A <= 9.8e-123: tmp = 180.0 * (math.atan(((C * 2.0) / B)) / math.pi) else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -7.6e+19) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (A <= -4.5e-162) tmp = Float64(Float64(180.0 / pi) * atan(Float64(B * Float64(-0.5 / C)))); elseif (A <= 9.8e-123) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C * 2.0) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -7.6e+19) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (A <= -4.5e-162) tmp = (180.0 / pi) * atan((B * (-0.5 / C))); elseif (A <= 9.8e-123) tmp = 180.0 * (atan(((C * 2.0) / B)) / pi); else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -7.6e+19], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -4.5e-162], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(B * N[(-0.5 / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 9.8e-123], N[(180.0 * N[(N[ArcTan[N[(N[(C * 2.0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -7.6 \cdot 10^{+19}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq -4.5 \cdot 10^{-162}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(B \cdot \frac{-0.5}{C}\right)\\
\mathbf{elif}\;A \leq 9.8 \cdot 10^{-123}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C \cdot 2}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -7.6e19Initial program 22.2%
Taylor expanded in A around -inf 76.9%
associate-*r/76.9%
Simplified76.9%
if -7.6e19 < A < -4.50000000000000023e-162Initial program 49.7%
Taylor expanded in C around inf 37.7%
Taylor expanded in A around inf 37.7%
associate-*r/37.9%
*-commutative37.9%
metadata-eval37.9%
distribute-lft-neg-in37.9%
neg-sub037.9%
metadata-eval37.9%
div037.9%
mul0-lft37.9%
cancel-sign-sub-inv37.9%
metadata-eval37.9%
+-commutative37.9%
fma-undefine37.9%
associate-/l*37.9%
Simplified37.9%
if -4.50000000000000023e-162 < A < 9.7999999999999996e-123Initial program 68.9%
Taylor expanded in C around -inf 40.1%
associate-*r/40.1%
*-commutative40.1%
Simplified40.1%
if 9.7999999999999996e-123 < A Initial program 77.2%
associate-*l/77.2%
*-lft-identity77.2%
+-commutative77.2%
unpow277.2%
unpow277.2%
hypot-define92.4%
Simplified92.4%
Taylor expanded in A around inf 64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in A around 0 64.4%
associate-*r/64.4%
*-commutative64.4%
associate-*r/64.4%
Simplified64.4%
Final simplification56.5%
(FPCore (A B C)
:precision binary64
(if (<= A -3.5e+19)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= A -4.4e-162)
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
(if (<= A 9.4e-124)
(* 180.0 (/ (atan (/ (* C 2.0) B)) PI))
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.5e+19) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (A <= -4.4e-162) {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
} else if (A <= 9.4e-124) {
tmp = 180.0 * (atan(((C * 2.0) / B)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.5e+19) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (A <= -4.4e-162) {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
} else if (A <= 9.4e-124) {
tmp = 180.0 * (Math.atan(((C * 2.0) / B)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.5e+19: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif A <= -4.4e-162: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) elif A <= 9.4e-124: tmp = 180.0 * (math.atan(((C * 2.0) / B)) / math.pi) else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.5e+19) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (A <= -4.4e-162) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); elseif (A <= 9.4e-124) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C * 2.0) / B)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.5e+19) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (A <= -4.4e-162) tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); elseif (A <= 9.4e-124) tmp = 180.0 * (atan(((C * 2.0) / B)) / pi); else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.5e+19], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -4.4e-162], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 9.4e-124], N[(180.0 * N[(N[ArcTan[N[(N[(C * 2.0), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3.5 \cdot 10^{+19}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq -4.4 \cdot 10^{-162}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{elif}\;A \leq 9.4 \cdot 10^{-124}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C \cdot 2}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.5e19Initial program 22.2%
Taylor expanded in A around -inf 76.9%
associate-*r/76.9%
Simplified76.9%
if -3.5e19 < A < -4.3999999999999998e-162Initial program 49.7%
Taylor expanded in C around inf 37.7%
Taylor expanded in A around inf 37.7%
if -4.3999999999999998e-162 < A < 9.40000000000000009e-124Initial program 68.9%
Taylor expanded in C around -inf 40.1%
associate-*r/40.1%
*-commutative40.1%
Simplified40.1%
if 9.40000000000000009e-124 < A Initial program 77.2%
associate-*l/77.2%
*-lft-identity77.2%
+-commutative77.2%
unpow277.2%
unpow277.2%
hypot-define92.4%
Simplified92.4%
Taylor expanded in A around inf 64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in A around 0 64.4%
associate-*r/64.4%
*-commutative64.4%
associate-*r/64.4%
Simplified64.4%
(FPCore (A B C)
:precision binary64
(if (<= B -9.8e+14)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B -4.3e-156)
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
(if (<= B 2.5e-14)
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI))
(* 180.0 (/ (atan -1.0) PI))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -9.8e+14) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= -4.3e-156) {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
} else if (B <= 2.5e-14) {
tmp = 180.0 * (atan((A * (-2.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 <= -9.8e+14) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= -4.3e-156) {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
} else if (B <= 2.5e-14) {
tmp = 180.0 * (Math.atan((A * (-2.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 <= -9.8e+14: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= -4.3e-156: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) elif B <= 2.5e-14: tmp = 180.0 * (math.atan((A * (-2.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 <= -9.8e+14) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= -4.3e-156) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); elseif (B <= 2.5e-14) tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.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 <= -9.8e+14) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= -4.3e-156) tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); elseif (B <= 2.5e-14) tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -9.8e+14], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, -4.3e-156], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.5e-14], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -9.8 \cdot 10^{+14}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq -4.3 \cdot 10^{-156}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{elif}\;B \leq 2.5 \cdot 10^{-14}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -9.8e14Initial program 52.4%
Taylor expanded in B around -inf 62.9%
if -9.8e14 < B < -4.29999999999999977e-156Initial program 50.6%
Taylor expanded in C around inf 37.7%
Taylor expanded in A around inf 37.7%
if -4.29999999999999977e-156 < B < 2.5000000000000001e-14Initial program 62.9%
associate-*l/62.9%
*-lft-identity62.9%
+-commutative62.9%
unpow262.9%
unpow262.9%
hypot-define84.1%
Simplified84.1%
Taylor expanded in A around inf 41.4%
*-commutative41.4%
Simplified41.4%
Taylor expanded in A around 0 41.4%
associate-*r/41.4%
*-commutative41.4%
associate-*r/41.4%
Simplified41.4%
if 2.5000000000000001e-14 < B Initial program 60.6%
Taylor expanded in B around inf 52.8%
(FPCore (A B C)
:precision binary64
(if (<= A -3.8e+35)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A -2.5e-56)
(/ 180.0 (/ PI (atan (/ (- C B) B))))
(/ 180.0 (/ PI (atan (+ 1.0 (/ (- C A) B))))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.8e+35) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= -2.5e-56) {
tmp = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
} else {
tmp = 180.0 / (((double) M_PI) / atan((1.0 + ((C - A) / B))));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.8e+35) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= -2.5e-56) {
tmp = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
} else {
tmp = 180.0 / (Math.PI / Math.atan((1.0 + ((C - A) / B))));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.8e+35: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= -2.5e-56: tmp = 180.0 / (math.pi / math.atan(((C - B) / B))) else: tmp = 180.0 / (math.pi / math.atan((1.0 + ((C - A) / B)))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.8e+35) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= -2.5e-56) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B)))); else tmp = Float64(180.0 / Float64(pi / atan(Float64(1.0 + Float64(Float64(C - A) / B))))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.8e+35) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= -2.5e-56) tmp = 180.0 / (pi / atan(((C - B) / B))); else tmp = 180.0 / (pi / atan((1.0 + ((C - A) / B)))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.8e+35], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.5e-56], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3.8 \cdot 10^{+35}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq -2.5 \cdot 10^{-56}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}}\\
\end{array}
\end{array}
if A < -3.8e35Initial program 20.9%
*-commutative20.9%
associate--l-15.5%
+-commutative15.5%
unpow215.5%
unpow215.5%
hypot-undefine22.8%
div-inv22.8%
clear-num22.8%
un-div-inv22.8%
Applied egg-rr54.1%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
*-commutative76.6%
Simplified76.6%
if -3.8e35 < A < -2.49999999999999999e-56Initial program 53.7%
*-commutative53.7%
associate--l-54.1%
+-commutative54.1%
unpow254.1%
unpow254.1%
hypot-undefine64.5%
div-inv64.5%
clear-num64.5%
un-div-inv64.5%
Applied egg-rr64.1%
Taylor expanded in A around 0 53.8%
+-commutative53.8%
unpow253.8%
unpow253.8%
hypot-define64.1%
Simplified64.1%
Taylor expanded in C around 0 62.3%
if -2.49999999999999999e-56 < A Initial program 70.6%
*-commutative70.6%
associate--l-70.6%
+-commutative70.6%
unpow270.6%
unpow270.6%
hypot-undefine88.3%
div-inv88.3%
clear-num88.3%
un-div-inv88.3%
Applied egg-rr88.3%
Taylor expanded in B around -inf 60.9%
associate--l+60.9%
div-sub63.1%
Simplified63.1%
Final simplification66.1%
(FPCore (A B C)
:precision binary64
(if (<= A -1.15e+37)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A -6e-56)
(/ 180.0 (/ PI (atan (/ (- C B) B))))
(* 180.0 (/ (atan (+ 1.0 (/ (- C A) B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.15e+37) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= -6e-56) {
tmp = 180.0 / (((double) M_PI) / atan(((C - B) / B)));
} else {
tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.15e+37) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= -6e-56) {
tmp = 180.0 / (Math.PI / Math.atan(((C - B) / B)));
} else {
tmp = 180.0 * (Math.atan((1.0 + ((C - A) / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.15e+37: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= -6e-56: tmp = 180.0 / (math.pi / math.atan(((C - B) / B))) else: tmp = 180.0 * (math.atan((1.0 + ((C - A) / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.15e+37) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= -6e-56) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(C - B) / B)))); else tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(Float64(C - A) / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.15e+37) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= -6e-56) tmp = 180.0 / (pi / atan(((C - B) / B))); else tmp = 180.0 * (atan((1.0 + ((C - A) / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.15e+37], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -6e-56], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.15 \cdot 10^{+37}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq -6 \cdot 10^{-56}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C - B}{B}\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C - A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.15000000000000001e37Initial program 20.9%
*-commutative20.9%
associate--l-15.5%
+-commutative15.5%
unpow215.5%
unpow215.5%
hypot-undefine22.8%
div-inv22.8%
clear-num22.8%
un-div-inv22.8%
Applied egg-rr54.1%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
*-commutative76.6%
Simplified76.6%
if -1.15000000000000001e37 < A < -5.99999999999999979e-56Initial program 53.7%
*-commutative53.7%
associate--l-54.1%
+-commutative54.1%
unpow254.1%
unpow254.1%
hypot-undefine64.5%
div-inv64.5%
clear-num64.5%
un-div-inv64.5%
Applied egg-rr64.1%
Taylor expanded in A around 0 53.8%
+-commutative53.8%
unpow253.8%
unpow253.8%
hypot-define64.1%
Simplified64.1%
Taylor expanded in C around 0 62.3%
if -5.99999999999999979e-56 < A Initial program 70.6%
Taylor expanded in B around -inf 60.9%
associate--l+60.9%
div-sub63.1%
Simplified63.1%
Final simplification66.0%
(FPCore (A B C)
:precision binary64
(if (<= A -1.6e+32)
(/ 180.0 (/ PI (atan (/ (* 0.5 B) A))))
(if (<= A 8e-102)
(* (/ 180.0 PI) (atan (+ 1.0 (/ C B))))
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.6e+32) {
tmp = 180.0 / (((double) M_PI) / atan(((0.5 * B) / A)));
} else if (A <= 8e-102) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + (C / B)));
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.6e+32) {
tmp = 180.0 / (Math.PI / Math.atan(((0.5 * B) / A)));
} else if (A <= 8e-102) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + (C / B)));
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.6e+32: tmp = 180.0 / (math.pi / math.atan(((0.5 * B) / A))) elif A <= 8e-102: tmp = (180.0 / math.pi) * math.atan((1.0 + (C / B))) else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.6e+32) tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(0.5 * B) / A)))); elseif (A <= 8e-102) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(C / B)))); else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.6e+32) tmp = 180.0 / (pi / atan(((0.5 * B) / A))); elseif (A <= 8e-102) tmp = (180.0 / pi) * atan((1.0 + (C / B))); else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.6e+32], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 8e-102], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.6 \cdot 10^{+32}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}}\\
\mathbf{elif}\;A \leq 8 \cdot 10^{-102}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.5999999999999999e32Initial program 20.9%
*-commutative20.9%
associate--l-15.5%
+-commutative15.5%
unpow215.5%
unpow215.5%
hypot-undefine22.8%
div-inv22.8%
clear-num22.8%
un-div-inv22.8%
Applied egg-rr54.1%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
*-commutative76.6%
Simplified76.6%
if -1.5999999999999999e32 < A < 7.99999999999999946e-102Initial program 62.3%
Taylor expanded in B around 0 62.4%
Simplified80.9%
Taylor expanded in A around 0 61.8%
+-commutative61.8%
unpow261.8%
unpow261.8%
hypot-define80.3%
Simplified80.3%
Taylor expanded in B around -inf 51.2%
+-commutative51.2%
Simplified51.2%
if 7.99999999999999946e-102 < A Initial program 78.2%
associate-*l/78.2%
*-lft-identity78.2%
+-commutative78.2%
unpow278.2%
unpow278.2%
hypot-define93.2%
Simplified93.2%
Taylor expanded in A around inf 67.1%
*-commutative67.1%
Simplified67.1%
Taylor expanded in A around 0 67.1%
associate-*r/67.1%
*-commutative67.1%
associate-*r/67.1%
Simplified67.1%
Final simplification62.1%
(FPCore (A B C)
:precision binary64
(if (<= A -1.9e+33)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= A 8e-102)
(* (/ 180.0 PI) (atan (+ 1.0 (/ C B))))
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e+33) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (A <= 8e-102) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + (C / B)));
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -1.9e+33) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (A <= 8e-102) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + (C / B)));
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -1.9e+33: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif A <= 8e-102: tmp = (180.0 / math.pi) * math.atan((1.0 + (C / B))) else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -1.9e+33) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (A <= 8e-102) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(C / B)))); else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -1.9e+33) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (A <= 8e-102) tmp = (180.0 / pi) * atan((1.0 + (C / B))); else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -1.9e+33], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 8e-102], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.9 \cdot 10^{+33}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 8 \cdot 10^{-102}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -1.90000000000000001e33Initial program 20.9%
Taylor expanded in A around -inf 76.6%
associate-*r/76.6%
Simplified76.6%
if -1.90000000000000001e33 < A < 7.99999999999999946e-102Initial program 62.3%
Taylor expanded in B around 0 62.4%
Simplified80.9%
Taylor expanded in A around 0 61.8%
+-commutative61.8%
unpow261.8%
unpow261.8%
hypot-define80.3%
Simplified80.3%
Taylor expanded in B around -inf 51.2%
+-commutative51.2%
Simplified51.2%
if 7.99999999999999946e-102 < A Initial program 78.2%
associate-*l/78.2%
*-lft-identity78.2%
+-commutative78.2%
unpow278.2%
unpow278.2%
hypot-define93.2%
Simplified93.2%
Taylor expanded in A around inf 67.1%
*-commutative67.1%
Simplified67.1%
Taylor expanded in A around 0 67.1%
associate-*r/67.1%
*-commutative67.1%
associate-*r/67.1%
Simplified67.1%
Final simplification62.1%
(FPCore (A B C)
:precision binary64
(if (<= A -3.4e+25)
(* 180.0 (/ (atan (/ (* 0.5 B) A)) PI))
(if (<= A 9e-97)
(* 180.0 (/ (atan (* -0.5 (/ B C))) PI))
(* 180.0 (/ (atan (* A (/ -2.0 B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.4e+25) {
tmp = 180.0 * (atan(((0.5 * B) / A)) / ((double) M_PI));
} else if (A <= 9e-97) {
tmp = 180.0 * (atan((-0.5 * (B / C))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((A * (-2.0 / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.4e+25) {
tmp = 180.0 * (Math.atan(((0.5 * B) / A)) / Math.PI);
} else if (A <= 9e-97) {
tmp = 180.0 * (Math.atan((-0.5 * (B / C))) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((A * (-2.0 / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.4e+25: tmp = 180.0 * (math.atan(((0.5 * B) / A)) / math.pi) elif A <= 9e-97: tmp = 180.0 * (math.atan((-0.5 * (B / C))) / math.pi) else: tmp = 180.0 * (math.atan((A * (-2.0 / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.4e+25) tmp = Float64(180.0 * Float64(atan(Float64(Float64(0.5 * B) / A)) / pi)); elseif (A <= 9e-97) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / C))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(A * Float64(-2.0 / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.4e+25) tmp = 180.0 * (atan(((0.5 * B) / A)) / pi); elseif (A <= 9e-97) tmp = 180.0 * (atan((-0.5 * (B / C))) / pi); else tmp = 180.0 * (atan((A * (-2.0 / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3.4e+25], N[(180.0 * N[(N[ArcTan[N[(N[(0.5 * B), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 9e-97], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(A * N[(-2.0 / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3.4 \cdot 10^{+25}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{0.5 \cdot B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 9 \cdot 10^{-97}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(A \cdot \frac{-2}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.39999999999999984e25Initial program 22.2%
Taylor expanded in A around -inf 76.9%
associate-*r/76.9%
Simplified76.9%
if -3.39999999999999984e25 < A < 9.0000000000000002e-97Initial program 61.1%
Taylor expanded in C around inf 33.0%
Taylor expanded in A around inf 33.0%
if 9.0000000000000002e-97 < A Initial program 79.8%
associate-*l/79.8%
*-lft-identity79.8%
+-commutative79.8%
unpow279.8%
unpow279.8%
hypot-define94.2%
Simplified94.2%
Taylor expanded in A around inf 68.7%
*-commutative68.7%
Simplified68.7%
Taylor expanded in A around 0 68.7%
associate-*r/68.7%
*-commutative68.7%
associate-*r/68.7%
Simplified68.7%
(FPCore (A B C)
:precision binary64
(if (<= B -3.15e-47)
(* 180.0 (/ (atan 1.0) PI))
(if (<= B 2.4e-152)
(* 180.0 (/ (atan 0.0) PI))
(* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -3.15e-47) {
tmp = 180.0 * (atan(1.0) / ((double) M_PI));
} else if (B <= 2.4e-152) {
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 <= -3.15e-47) {
tmp = 180.0 * (Math.atan(1.0) / Math.PI);
} else if (B <= 2.4e-152) {
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 <= -3.15e-47: tmp = 180.0 * (math.atan(1.0) / math.pi) elif B <= 2.4e-152: 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 <= -3.15e-47) tmp = Float64(180.0 * Float64(atan(1.0) / pi)); elseif (B <= 2.4e-152) 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 <= -3.15e-47) tmp = 180.0 * (atan(1.0) / pi); elseif (B <= 2.4e-152) 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, -3.15e-47], N[(180.0 * N[(N[ArcTan[1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 2.4e-152], 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 -3.15 \cdot 10^{-47}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 1}{\pi}\\
\mathbf{elif}\;B \leq 2.4 \cdot 10^{-152}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < -3.1500000000000001e-47Initial program 53.1%
Taylor expanded in B around -inf 55.0%
if -3.1500000000000001e-47 < B < 2.4e-152Initial program 60.7%
Taylor expanded in C around inf 33.5%
Taylor expanded in B around 0 34.4%
distribute-rgt1-in34.4%
metadata-eval34.4%
mul0-lft34.4%
div034.4%
metadata-eval34.4%
Simplified34.4%
if 2.4e-152 < B Initial program 59.3%
Taylor expanded in B around inf 42.7%
(FPCore (A B C) :precision binary64 (if (<= B 2.8e-154) (* 180.0 (/ (atan 0.0) PI)) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= 2.8e-154) {
tmp = 180.0 * (atan(0.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 2.8e-154) {
tmp = 180.0 * (Math.atan(0.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 2.8e-154: tmp = 180.0 * (math.atan(0.0) / math.pi) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 2.8e-154) 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 <= 2.8e-154) tmp = 180.0 * (atan(0.0) / pi); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 2.8e-154], 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 2.8 \cdot 10^{-154}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < 2.80000000000000012e-154Initial program 57.9%
Taylor expanded in C around inf 27.1%
Taylor expanded in B around 0 23.0%
distribute-rgt1-in23.0%
metadata-eval23.0%
mul0-lft23.0%
div023.0%
metadata-eval23.0%
Simplified23.0%
if 2.80000000000000012e-154 < B Initial program 59.3%
Taylor expanded in B around inf 42.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 58.4%
Taylor expanded in B around inf 18.6%
herbie shell --seed 2024132
(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)))