
(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 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan (* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0)))))) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} \left(\frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\right)}{\pi}
\end{array}
(FPCore (A B C)
:precision binary64
(let* ((t_0 (* (atan (/ (- C (+ A (hypot B (- C A)))) B)) (/ 180.0 PI)))
(t_1
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
(if (<= t_1 -0.5)
t_0
(if (<= t_1 0.0)
(/
(atan
(*
B
(+
(/ (/ (* B (* B 0.125)) (- C A)) (* (- C A) (- C A)))
(/ -0.5 (- C A)))))
(/ PI 180.0))
t_0))))
double code(double A, double B, double C) {
double t_0 = atan(((C - (A + hypot(B, (C - A)))) / B)) * (180.0 / ((double) M_PI));
double t_1 = (1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0))));
double tmp;
if (t_1 <= -0.5) {
tmp = t_0;
} else if (t_1 <= 0.0) {
tmp = atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (((double) M_PI) / 180.0);
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = Math.atan(((C - (A + Math.hypot(B, (C - A)))) / B)) * (180.0 / Math.PI);
double t_1 = (1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0))));
double tmp;
if (t_1 <= -0.5) {
tmp = t_0;
} else if (t_1 <= 0.0) {
tmp = Math.atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (Math.PI / 180.0);
} else {
tmp = t_0;
}
return tmp;
}
def code(A, B, C): t_0 = math.atan(((C - (A + math.hypot(B, (C - A)))) / B)) * (180.0 / math.pi) t_1 = (1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))) tmp = 0 if t_1 <= -0.5: tmp = t_0 elif t_1 <= 0.0: tmp = math.atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (math.pi / 180.0) else: tmp = t_0 return tmp
function code(A, B, C) t_0 = Float64(atan(Float64(Float64(C - Float64(A + hypot(B, Float64(C - A)))) / B)) * Float64(180.0 / pi)) t_1 = Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))) tmp = 0.0 if (t_1 <= -0.5) tmp = t_0; elseif (t_1 <= 0.0) tmp = Float64(atan(Float64(B * Float64(Float64(Float64(Float64(B * Float64(B * 0.125)) / Float64(C - A)) / Float64(Float64(C - A) * Float64(C - A))) + Float64(-0.5 / Float64(C - A))))) / Float64(pi / 180.0)); else tmp = t_0; end return tmp end
function tmp_2 = code(A, B, C) t_0 = atan(((C - (A + hypot(B, (C - A)))) / B)) * (180.0 / pi); t_1 = (1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))); tmp = 0.0; if (t_1 <= -0.5) tmp = t_0; elseif (t_1 <= 0.0) tmp = atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (pi / 180.0); else tmp = t_0; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[ArcTan[N[(N[(C - N[(A + N[Sqrt[B ^ 2 + N[(C - A), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -0.5], t$95$0, If[LessEqual[t$95$1, 0.0], N[(N[ArcTan[N[(B * N[(N[(N[(N[(B * N[(B * 0.125), $MachinePrecision]), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision] / N[(N[(C - A), $MachinePrecision] * N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(Pi / 180.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(B, C - A\right)\right)}{B}\right) \cdot \frac{180}{\pi}\\
t_1 := \frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\\
\mathbf{if}\;t\_1 \leq -0.5:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{\tan^{-1} \left(B \cdot \left(\frac{\frac{B \cdot \left(B \cdot 0.125\right)}{C - A}}{\left(C - A\right) \cdot \left(C - A\right)} + \frac{-0.5}{C - A}\right)\right)}{\frac{\pi}{180}}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) < -0.5 or 0.0 < (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) Initial program 65.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified87.8%
if -0.5 < (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) < 0.0Initial program 15.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified10.8%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified76.5%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.5%
(FPCore (A B C)
:precision binary64
(if (<= A -7.6e+122)
(* (/ 180.0 PI) (atan (/ (* B -0.5) (- C A))))
(if (<= A 2.1e-114)
(* (/ 180.0 PI) (atan (/ (- C (hypot C B)) B)))
(* (/ 180.0 PI) (atan (/ (- C (+ A (hypot A B))) B))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -7.6e+122) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * -0.5) / (C - A)));
} else if (A <= 2.1e-114) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - hypot(C, B)) / B));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - (A + hypot(A, B))) / B));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -7.6e+122) {
tmp = (180.0 / Math.PI) * Math.atan(((B * -0.5) / (C - A)));
} else if (A <= 2.1e-114) {
tmp = (180.0 / Math.PI) * Math.atan(((C - Math.hypot(C, B)) / B));
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - (A + Math.hypot(A, B))) / B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -7.6e+122: tmp = (180.0 / math.pi) * math.atan(((B * -0.5) / (C - A))) elif A <= 2.1e-114: tmp = (180.0 / math.pi) * math.atan(((C - math.hypot(C, B)) / B)) else: tmp = (180.0 / math.pi) * math.atan(((C - (A + math.hypot(A, B))) / B)) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -7.6e+122) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * -0.5) / Float64(C - A)))); elseif (A <= 2.1e-114) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - hypot(C, B)) / B))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(A + hypot(A, B))) / B))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -7.6e+122) tmp = (180.0 / pi) * atan(((B * -0.5) / (C - A))); elseif (A <= 2.1e-114) tmp = (180.0 / pi) * atan(((C - hypot(C, B)) / B)); else tmp = (180.0 / pi) * atan(((C - (A + hypot(A, B))) / B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -7.6e+122], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 2.1e-114], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(A + N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -7.6 \cdot 10^{+122}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C - A}\right)\\
\mathbf{elif}\;A \leq 2.1 \cdot 10^{-114}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(A + \mathsf{hypot}\left(A, B\right)\right)}{B}\right)\\
\end{array}
\end{array}
if A < -7.5999999999999996e122Initial program 11.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified22.4%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified68.6%
Taylor expanded in B around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6484.1%
Simplified84.1%
if -7.5999999999999996e122 < A < 2.09999999999999993e-114Initial program 57.5%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified80.2%
Taylor expanded in A around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6479.2%
Simplified79.2%
if 2.09999999999999993e-114 < A Initial program 73.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified91.5%
Taylor expanded in C around 0
+-lowering-+.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6487.3%
Simplified87.3%
Final simplification82.9%
(FPCore (A B C)
:precision binary64
(if (<= A -1e+123)
(* (/ 180.0 PI) (atan (/ (* B -0.5) (- C A))))
(if (<= A 8.4e-55)
(* (/ 180.0 PI) (atan (/ (- C (hypot C B)) B)))
(* (/ 180.0 PI) (atan (+ 1.0 (/ (- C A) B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -1e+123) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * -0.5) / (C - A)));
} else if (A <= 8.4e-55) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - hypot(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 <= -1e+123) {
tmp = (180.0 / Math.PI) * Math.atan(((B * -0.5) / (C - A)));
} else if (A <= 8.4e-55) {
tmp = (180.0 / Math.PI) * Math.atan(((C - Math.hypot(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 <= -1e+123: tmp = (180.0 / math.pi) * math.atan(((B * -0.5) / (C - A))) elif A <= 8.4e-55: tmp = (180.0 / math.pi) * math.atan(((C - math.hypot(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 <= -1e+123) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * -0.5) / Float64(C - A)))); elseif (A <= 8.4e-55) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - hypot(C, B)) / B))); else tmp = Float64(Float64(180.0 / 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 <= -1e+123) tmp = (180.0 / pi) * atan(((B * -0.5) / (C - A))); elseif (A <= 8.4e-55) tmp = (180.0 / pi) * atan(((C - hypot(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, -1e+123], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 8.4e-55], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[Sqrt[C ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1 \cdot 10^{+123}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C - A}\right)\\
\mathbf{elif}\;A \leq 8.4 \cdot 10^{-55}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C, B\right)}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)\\
\end{array}
\end{array}
if A < -9.99999999999999978e122Initial program 11.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified22.4%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified68.6%
Taylor expanded in B around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6484.1%
Simplified84.1%
if -9.99999999999999978e122 < A < 8.4000000000000006e-55Initial program 57.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified80.8%
Taylor expanded in A around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6478.7%
Simplified78.7%
if 8.4000000000000006e-55 < A Initial program 75.8%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified92.3%
Taylor expanded in B around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6482.2%
Simplified82.2%
Final simplification80.5%
(FPCore (A B C)
:precision binary64
(if (<= B 9e-189)
(* (/ 180.0 PI) (atan (+ 1.0 (/ (- C A) B))))
(if (<= B 1.25e-97)
(/
(atan
(*
B
(+
(/ (/ (* B (* B 0.125)) (- C A)) (* (- C A) (- C A)))
(/ -0.5 (- C A)))))
(/ PI 180.0))
(/ 180.0 (/ PI (atan (/ (- (* C (+ 1.0 (/ (* C -0.5) B))) B) B)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= 9e-189) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + ((C - A) / B)));
} else if (B <= 1.25e-97) {
tmp = atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (((double) M_PI) / 180.0);
} else {
tmp = 180.0 / (((double) M_PI) / atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 9e-189) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + ((C - A) / B)));
} else if (B <= 1.25e-97) {
tmp = Math.atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (Math.PI / 180.0);
} else {
tmp = 180.0 / (Math.PI / Math.atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 9e-189: tmp = (180.0 / math.pi) * math.atan((1.0 + ((C - A) / B))) elif B <= 1.25e-97: tmp = math.atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (math.pi / 180.0) else: tmp = 180.0 / (math.pi / math.atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B))) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 9e-189) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(Float64(C - A) / B)))); elseif (B <= 1.25e-97) tmp = Float64(atan(Float64(B * Float64(Float64(Float64(Float64(B * Float64(B * 0.125)) / Float64(C - A)) / Float64(Float64(C - A) * Float64(C - A))) + Float64(-0.5 / Float64(C - A))))) / Float64(pi / 180.0)); else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C * Float64(1.0 + Float64(Float64(C * -0.5) / B))) - B) / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 9e-189) tmp = (180.0 / pi) * atan((1.0 + ((C - A) / B))); elseif (B <= 1.25e-97) tmp = atan((B * ((((B * (B * 0.125)) / (C - A)) / ((C - A) * (C - A))) + (-0.5 / (C - A))))) / (pi / 180.0); else tmp = 180.0 / (pi / atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 9e-189], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.25e-97], N[(N[ArcTan[N[(B * N[(N[(N[(N[(B * N[(B * 0.125), $MachinePrecision]), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision] / N[(N[(C - A), $MachinePrecision] * N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(Pi / 180.0), $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C * N[(1.0 + N[(N[(C * -0.5), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 9 \cdot 10^{-189}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)\\
\mathbf{elif}\;B \leq 1.25 \cdot 10^{-97}:\\
\;\;\;\;\frac{\tan^{-1} \left(B \cdot \left(\frac{\frac{B \cdot \left(B \cdot 0.125\right)}{C - A}}{\left(C - A\right) \cdot \left(C - A\right)} + \frac{-0.5}{C - A}\right)\right)}{\frac{\pi}{180}}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C \cdot \left(1 + \frac{C \cdot -0.5}{B}\right) - B}{B}\right)}}\\
\end{array}
\end{array}
if B < 8.9999999999999992e-189Initial program 62.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified79.4%
Taylor expanded in B around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6472.7%
Simplified72.7%
if 8.9999999999999992e-189 < B < 1.2499999999999999e-97Initial program 37.5%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified59.5%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified55.4%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
Applied egg-rr67.2%
if 1.2499999999999999e-97 < B Initial program 56.8%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6481.4%
Applied egg-rr81.4%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6461.0%
Simplified61.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
atan-lowering-atan.f64N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f6461.0%
Applied egg-rr61.0%
Taylor expanded in C around 0
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6467.3%
Simplified67.3%
Final simplification70.6%
(FPCore (A B C)
:precision binary64
(if (<= B 9.5e-189)
(* (/ 180.0 PI) (atan (+ 1.0 (/ (- C A) B))))
(if (<= B 1.16e-98)
(* (/ 180.0 PI) (atan (/ (* B -0.5) (- C A))))
(/ 180.0 (/ PI (atan (/ (- (* C (+ 1.0 (/ (* C -0.5) B))) B) B)))))))
double code(double A, double B, double C) {
double tmp;
if (B <= 9.5e-189) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 + ((C - A) / B)));
} else if (B <= 1.16e-98) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * -0.5) / (C - A)));
} else {
tmp = 180.0 / (((double) M_PI) / atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 9.5e-189) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 + ((C - A) / B)));
} else if (B <= 1.16e-98) {
tmp = (180.0 / Math.PI) * Math.atan(((B * -0.5) / (C - A)));
} else {
tmp = 180.0 / (Math.PI / Math.atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 9.5e-189: tmp = (180.0 / math.pi) * math.atan((1.0 + ((C - A) / B))) elif B <= 1.16e-98: tmp = (180.0 / math.pi) * math.atan(((B * -0.5) / (C - A))) else: tmp = 180.0 / (math.pi / math.atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B))) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 9.5e-189) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 + Float64(Float64(C - A) / B)))); elseif (B <= 1.16e-98) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * -0.5) / Float64(C - A)))); else tmp = Float64(180.0 / Float64(pi / atan(Float64(Float64(Float64(C * Float64(1.0 + Float64(Float64(C * -0.5) / B))) - B) / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 9.5e-189) tmp = (180.0 / pi) * atan((1.0 + ((C - A) / B))); elseif (B <= 1.16e-98) tmp = (180.0 / pi) * atan(((B * -0.5) / (C - A))); else tmp = 180.0 / (pi / atan((((C * (1.0 + ((C * -0.5) / B))) - B) / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 9.5e-189], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.16e-98], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 / N[(Pi / N[ArcTan[N[(N[(N[(C * N[(1.0 + N[(N[(C * -0.5), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 9.5 \cdot 10^{-189}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)\\
\mathbf{elif}\;B \leq 1.16 \cdot 10^{-98}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C - A}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\frac{\pi}{\tan^{-1} \left(\frac{C \cdot \left(1 + \frac{C \cdot -0.5}{B}\right) - B}{B}\right)}}\\
\end{array}
\end{array}
if B < 9.499999999999999e-189Initial program 62.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified79.4%
Taylor expanded in B around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6472.7%
Simplified72.7%
if 9.499999999999999e-189 < B < 1.15999999999999994e-98Initial program 37.5%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified59.5%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified55.4%
Taylor expanded in B around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6467.1%
Simplified67.1%
if 1.15999999999999994e-98 < B Initial program 56.8%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6481.4%
Applied egg-rr81.4%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6461.0%
Simplified61.0%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
atan-lowering-atan.f64N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f6461.0%
Applied egg-rr61.0%
Taylor expanded in C around 0
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6467.3%
Simplified67.3%
Final simplification70.6%
(FPCore (A B C)
:precision binary64
(if (<= A -4.5e-27)
(* (/ 180.0 PI) (atan (/ (* B -0.5) (- C A))))
(if (<= A -2.8e-168)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= A 1.05e-261)
(* (/ 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 <= -4.5e-27) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * -0.5) / (C - A)));
} else if (A <= -2.8e-168) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (A <= 1.05e-261) {
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 <= -4.5e-27) {
tmp = (180.0 / Math.PI) * Math.atan(((B * -0.5) / (C - A)));
} else if (A <= -2.8e-168) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (A <= 1.05e-261) {
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 <= -4.5e-27: tmp = (180.0 / math.pi) * math.atan(((B * -0.5) / (C - A))) elif A <= -2.8e-168: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif A <= 1.05e-261: 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 <= -4.5e-27) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * -0.5) / Float64(C - A)))); elseif (A <= -2.8e-168) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (A <= 1.05e-261) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(Float64(180.0 / 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 <= -4.5e-27) tmp = (180.0 / pi) * atan(((B * -0.5) / (C - A))); elseif (A <= -2.8e-168) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (A <= 1.05e-261) 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, -4.5e-27], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.8e-168], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.05e-261], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -4.5 \cdot 10^{-27}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C - A}\right)\\
\mathbf{elif}\;A \leq -2.8 \cdot 10^{-168}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.05 \cdot 10^{-261}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)\\
\end{array}
\end{array}
if A < -4.5000000000000002e-27Initial program 25.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified43.7%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified51.0%
Taylor expanded in B around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f6465.8%
Simplified65.8%
if -4.5000000000000002e-27 < A < -2.8000000000000002e-168Initial program 77.4%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6485.8%
Applied egg-rr85.8%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6485.6%
Simplified85.6%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6478.5%
Simplified78.5%
if -2.8000000000000002e-168 < A < 1.04999999999999998e-261Initial program 52.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified88.2%
Taylor expanded in B around inf
Simplified61.0%
if 1.04999999999999998e-261 < A Initial program 74.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified90.9%
Taylor expanded in B around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6476.1%
Simplified76.1%
Final simplification71.5%
(FPCore (A B C)
:precision binary64
(if (<= A -1.1e-27)
(* (/ 180.0 PI) (atan (* -0.5 (/ B (- C A)))))
(if (<= A -2e-172)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= A 1e-261)
(* (/ 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 <= -1.1e-27) {
tmp = (180.0 / ((double) M_PI)) * atan((-0.5 * (B / (C - A))));
} else if (A <= -2e-172) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (A <= 1e-261) {
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 <= -1.1e-27) {
tmp = (180.0 / Math.PI) * Math.atan((-0.5 * (B / (C - A))));
} else if (A <= -2e-172) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (A <= 1e-261) {
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 <= -1.1e-27: tmp = (180.0 / math.pi) * math.atan((-0.5 * (B / (C - A)))) elif A <= -2e-172: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif A <= 1e-261: 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 <= -1.1e-27) tmp = Float64(Float64(180.0 / pi) * atan(Float64(-0.5 * Float64(B / Float64(C - A))))); elseif (A <= -2e-172) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (A <= 1e-261) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(Float64(180.0 / 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 <= -1.1e-27) tmp = (180.0 / pi) * atan((-0.5 * (B / (C - A)))); elseif (A <= -2e-172) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (A <= 1e-261) 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, -1.1e-27], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2e-172], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1e-261], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 + N[(N[(C - A), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -1.1 \cdot 10^{-27}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)\\
\mathbf{elif}\;A \leq -2 \cdot 10^{-172}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq 10^{-261}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 + \frac{C - A}{B}\right)\\
\end{array}
\end{array}
if A < -1.09999999999999993e-27Initial program 25.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified43.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6465.8%
Simplified65.8%
if -1.09999999999999993e-27 < A < -2.0000000000000001e-172Initial program 77.4%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6485.8%
Applied egg-rr85.8%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6485.6%
Simplified85.6%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6478.5%
Simplified78.5%
if -2.0000000000000001e-172 < A < 9.99999999999999984e-262Initial program 52.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified88.2%
Taylor expanded in B around inf
Simplified61.0%
if 9.99999999999999984e-262 < A Initial program 74.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified90.9%
Taylor expanded in B around -inf
associate--l+N/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6476.1%
Simplified76.1%
Final simplification71.5%
(FPCore (A B C)
:precision binary64
(if (<= A -6e-28)
(* (/ 180.0 PI) (atan (* -0.5 (/ B (- C A)))))
(if (<= A -2.8e-183)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= A 1.65e-189)
(* (/ 180.0 PI) (atan (/ (- C B) B)))
(* (/ 180.0 PI) (atan (- 1.0 (/ A B))))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -6e-28) {
tmp = (180.0 / ((double) M_PI)) * atan((-0.5 * (B / (C - A))));
} else if (A <= -2.8e-183) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (A <= 1.65e-189) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
} else {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - (A / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -6e-28) {
tmp = (180.0 / Math.PI) * Math.atan((-0.5 * (B / (C - A))));
} else if (A <= -2.8e-183) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (A <= 1.65e-189) {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
} else {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - (A / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -6e-28: tmp = (180.0 / math.pi) * math.atan((-0.5 * (B / (C - A)))) elif A <= -2.8e-183: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif A <= 1.65e-189: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) else: tmp = (180.0 / math.pi) * math.atan((1.0 - (A / B))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -6e-28) tmp = Float64(Float64(180.0 / pi) * atan(Float64(-0.5 * Float64(B / Float64(C - A))))); elseif (A <= -2.8e-183) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (A <= 1.65e-189) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - Float64(A / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -6e-28) tmp = (180.0 / pi) * atan((-0.5 * (B / (C - A)))); elseif (A <= -2.8e-183) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (A <= 1.65e-189) tmp = (180.0 / pi) * atan(((C - B) / B)); else tmp = (180.0 / pi) * atan((1.0 - (A / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -6e-28], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.8e-183], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.65e-189], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -6 \cdot 10^{-28}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)\\
\mathbf{elif}\;A \leq -2.8 \cdot 10^{-183}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.65 \cdot 10^{-189}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)\\
\end{array}
\end{array}
if A < -6.00000000000000005e-28Initial program 25.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified43.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6465.8%
Simplified65.8%
if -6.00000000000000005e-28 < A < -2.79999999999999985e-183Initial program 77.4%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6485.8%
Applied egg-rr85.8%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6485.6%
Simplified85.6%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6478.5%
Simplified78.5%
if -2.79999999999999985e-183 < A < 1.65e-189Initial program 61.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified89.7%
Taylor expanded in B around inf
Simplified60.5%
if 1.65e-189 < A Initial program 72.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified90.5%
Taylor expanded in B around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified41.7%
Taylor expanded in C around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6439.7%
Simplified39.7%
Taylor expanded in A around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification68.8%
(FPCore (A B C)
:precision binary64
(if (<= A -3300000.0)
(* (/ 180.0 PI) (atan (/ (* B 0.5) A)))
(if (<= A -2.8e-164)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= A 1.95e-189)
(* (/ 180.0 PI) (atan (/ (- C B) B)))
(* (/ 180.0 PI) (atan (- 1.0 (/ A B))))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -3300000.0) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * 0.5) / A));
} else if (A <= -2.8e-164) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (A <= 1.95e-189) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
} else {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - (A / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3300000.0) {
tmp = (180.0 / Math.PI) * Math.atan(((B * 0.5) / A));
} else if (A <= -2.8e-164) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (A <= 1.95e-189) {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
} else {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - (A / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -3300000.0: tmp = (180.0 / math.pi) * math.atan(((B * 0.5) / A)) elif A <= -2.8e-164: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif A <= 1.95e-189: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) else: tmp = (180.0 / math.pi) * math.atan((1.0 - (A / B))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -3300000.0) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * 0.5) / A))); elseif (A <= -2.8e-164) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (A <= 1.95e-189) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - Float64(A / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3300000.0) tmp = (180.0 / pi) * atan(((B * 0.5) / A)); elseif (A <= -2.8e-164) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (A <= 1.95e-189) tmp = (180.0 / pi) * atan(((C - B) / B)); else tmp = (180.0 / pi) * atan((1.0 - (A / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -3300000.0], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, -2.8e-164], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.95e-189], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -3300000:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)\\
\mathbf{elif}\;A \leq -2.8 \cdot 10^{-164}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.95 \cdot 10^{-189}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)\\
\end{array}
\end{array}
if A < -3.3e6Initial program 23.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified43.7%
Taylor expanded in A around -inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6463.2%
Simplified63.2%
if -3.3e6 < A < -2.8000000000000001e-164Initial program 70.8%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6476.9%
Applied egg-rr76.9%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6477.3%
Simplified77.3%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6471.2%
Simplified71.2%
if -2.8000000000000001e-164 < A < 1.95000000000000012e-189Initial program 61.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified89.7%
Taylor expanded in B around inf
Simplified60.5%
if 1.95000000000000012e-189 < A Initial program 72.9%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified90.5%
Taylor expanded in B around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified41.7%
Taylor expanded in C around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6439.7%
Simplified39.7%
Taylor expanded in A around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification67.8%
(FPCore (A B C)
:precision binary64
(if (<= C -9e+40)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= C 7.2e+55)
(* (/ 180.0 PI) (atan (- 1.0 (/ A B))))
(* (/ 180.0 PI) (atan (/ (* B -0.5) C))))))
double code(double A, double B, double C) {
double tmp;
if (C <= -9e+40) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (C <= 7.2e+55) {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - (A / B)));
} 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 <= -9e+40) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (C <= 7.2e+55) {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - (A / B)));
} else {
tmp = (180.0 / Math.PI) * Math.atan(((B * -0.5) / C));
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= -9e+40: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif C <= 7.2e+55: tmp = (180.0 / math.pi) * math.atan((1.0 - (A / B))) else: tmp = (180.0 / math.pi) * math.atan(((B * -0.5) / C)) return tmp
function code(A, B, C) tmp = 0.0 if (C <= -9e+40) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (C <= 7.2e+55) tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - Float64(A / B)))); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * -0.5) / C))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -9e+40) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (C <= 7.2e+55) tmp = (180.0 / pi) * atan((1.0 - (A / B))); else tmp = (180.0 / pi) * atan(((B * -0.5) / C)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, -9e+40], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 7.2e+55], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * -0.5), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq -9 \cdot 10^{+40}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;C \leq 7.2 \cdot 10^{+55}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot -0.5}{C}\right)\\
\end{array}
\end{array}
if C < -9.00000000000000064e40Initial program 80.9%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6494.1%
Applied egg-rr94.1%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6494.2%
Simplified94.2%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6490.1%
Simplified90.1%
if -9.00000000000000064e40 < C < 7.19999999999999975e55Initial program 62.8%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified79.9%
Taylor expanded in B around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified39.6%
Taylor expanded in C around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.3%
Simplified37.3%
Taylor expanded in A around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6456.1%
Simplified56.1%
if 7.19999999999999975e55 < C Initial program 23.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified57.1%
Taylor expanded in B around 0
sub-negN/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified62.4%
Taylor expanded in C around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6474.5%
Simplified74.5%
Final simplification66.0%
(FPCore (A B C)
:precision binary64
(if (<= A -780000000.0)
(* (/ 180.0 PI) (atan (/ (* B 0.5) A)))
(if (<= A 6.8e-109)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(* (/ 180.0 PI) (atan (- 1.0 (/ A B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -780000000.0) {
tmp = (180.0 / ((double) M_PI)) * atan(((B * 0.5) / A));
} else if (A <= 6.8e-109) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - (A / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -780000000.0) {
tmp = (180.0 / Math.PI) * Math.atan(((B * 0.5) / A));
} else if (A <= 6.8e-109) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - (A / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -780000000.0: tmp = (180.0 / math.pi) * math.atan(((B * 0.5) / A)) elif A <= 6.8e-109: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan((1.0 - (A / B))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -780000000.0) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(B * 0.5) / A))); elseif (A <= 6.8e-109) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - Float64(A / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -780000000.0) tmp = (180.0 / pi) * atan(((B * 0.5) / A)); elseif (A <= 6.8e-109) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); else tmp = (180.0 / pi) * atan((1.0 - (A / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -780000000.0], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 6.8e-109], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -780000000:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)\\
\mathbf{elif}\;A \leq 6.8 \cdot 10^{-109}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)\\
\end{array}
\end{array}
if A < -7.8e8Initial program 23.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified43.7%
Taylor expanded in A around -inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6463.2%
Simplified63.2%
if -7.8e8 < A < 6.80000000000000023e-109Initial program 65.6%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6480.1%
Applied egg-rr80.1%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6478.7%
Simplified78.7%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6456.4%
Simplified56.4%
if 6.80000000000000023e-109 < A Initial program 73.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified91.3%
Taylor expanded in B around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified40.4%
Taylor expanded in C around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.7%
Simplified38.7%
Taylor expanded in A around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.0%
Simplified77.0%
Final simplification65.8%
(FPCore (A B C)
:precision binary64
(if (<= A -225000000.0)
(* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
(if (<= A 9.2e-109)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(* (/ 180.0 PI) (atan (- 1.0 (/ A B)))))))
double code(double A, double B, double C) {
double tmp;
if (A <= -225000000.0) {
tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
} else if (A <= 9.2e-109) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan((1.0 - (A / B)));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -225000000.0) {
tmp = 180.0 * (Math.atan(((B * 0.5) / A)) / Math.PI);
} else if (A <= 9.2e-109) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan((1.0 - (A / B)));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -225000000.0: tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi) elif A <= 9.2e-109: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan((1.0 - (A / B))) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -225000000.0) tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi)); elseif (A <= 9.2e-109) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(1.0 - Float64(A / B)))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -225000000.0) tmp = 180.0 * (atan(((B * 0.5) / A)) / pi); elseif (A <= 9.2e-109) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); else tmp = (180.0 / pi) * atan((1.0 - (A / B))); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -225000000.0], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 9.2e-109], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(1.0 - N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -225000000:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 9.2 \cdot 10^{-109}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(1 - \frac{A}{B}\right)\\
\end{array}
\end{array}
if A < -2.25e8Initial program 23.3%
Taylor expanded in A around -inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6463.2%
Simplified63.2%
if -2.25e8 < A < 9.2000000000000006e-109Initial program 65.6%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6480.1%
Applied egg-rr80.1%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6478.7%
Simplified78.7%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6456.4%
Simplified56.4%
if 9.2000000000000006e-109 < A Initial program 73.3%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified91.3%
Taylor expanded in B around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified40.4%
Taylor expanded in C around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.7%
Simplified38.7%
Taylor expanded in A around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.0%
Simplified77.0%
Final simplification65.8%
(FPCore (A B C)
:precision binary64
(if (<= B 3.1e-168)
(* 180.0 (/ (atan (+ 1.0 (/ C B))) PI))
(if (<= B 7e+19)
(* 180.0 (/ (atan (/ (* B 0.5) A)) PI))
(* (/ 180.0 PI) (atan -1.0)))))
double code(double A, double B, double C) {
double tmp;
if (B <= 3.1e-168) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else if (B <= 7e+19) {
tmp = 180.0 * (atan(((B * 0.5) / A)) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(-1.0);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 3.1e-168) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else if (B <= 7e+19) {
tmp = 180.0 * (Math.atan(((B * 0.5) / A)) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(-1.0);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 3.1e-168: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) elif B <= 7e+19: tmp = 180.0 * (math.atan(((B * 0.5) / A)) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(-1.0) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 3.1e-168) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); elseif (B <= 7e+19) tmp = Float64(180.0 * Float64(atan(Float64(Float64(B * 0.5) / A)) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(-1.0)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 3.1e-168) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); elseif (B <= 7e+19) tmp = 180.0 * (atan(((B * 0.5) / A)) / pi); else tmp = (180.0 / pi) * atan(-1.0); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 3.1e-168], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 7e+19], N[(180.0 * N[(N[ArcTan[N[(N[(B * 0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[-1.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 3.1 \cdot 10^{-168}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{elif}\;B \leq 7 \cdot 10^{+19}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{B \cdot 0.5}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} -1\\
\end{array}
\end{array}
if B < 3.1e-168Initial program 62.2%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6474.3%
Applied egg-rr74.3%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6462.4%
Simplified62.4%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6458.9%
Simplified58.9%
if 3.1e-168 < B < 7e19Initial program 53.3%
Taylor expanded in A around -inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6436.2%
Simplified36.2%
if 7e19 < B Initial program 53.6%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified88.2%
Taylor expanded in B around inf
Simplified62.1%
Final simplification56.2%
(FPCore (A B C)
:precision binary64
(if (<= B -5.8e-85)
(* (/ 180.0 PI) (atan 1.0))
(if (<= B 5.3e-108)
(* (/ 180.0 PI) (atan (/ C B)))
(* (/ 180.0 PI) (atan -1.0)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5.8e-85) {
tmp = (180.0 / ((double) M_PI)) * atan(1.0);
} else if (B <= 5.3e-108) {
tmp = (180.0 / ((double) M_PI)) * atan((C / B));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(-1.0);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -5.8e-85) {
tmp = (180.0 / Math.PI) * Math.atan(1.0);
} else if (B <= 5.3e-108) {
tmp = (180.0 / Math.PI) * Math.atan((C / B));
} else {
tmp = (180.0 / Math.PI) * Math.atan(-1.0);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5.8e-85: tmp = (180.0 / math.pi) * math.atan(1.0) elif B <= 5.3e-108: tmp = (180.0 / math.pi) * math.atan((C / B)) else: tmp = (180.0 / math.pi) * math.atan(-1.0) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5.8e-85) tmp = Float64(Float64(180.0 / pi) * atan(1.0)); elseif (B <= 5.3e-108) tmp = Float64(Float64(180.0 / pi) * atan(Float64(C / B))); else tmp = Float64(Float64(180.0 / pi) * atan(-1.0)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5.8e-85) tmp = (180.0 / pi) * atan(1.0); elseif (B <= 5.3e-108) tmp = (180.0 / pi) * atan((C / B)); else tmp = (180.0 / pi) * atan(-1.0); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5.8e-85], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[1.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 5.3e-108], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(C / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[-1.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5.8 \cdot 10^{-85}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} 1\\
\mathbf{elif}\;B \leq 5.3 \cdot 10^{-108}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} -1\\
\end{array}
\end{array}
if B < -5.8000000000000004e-85Initial program 56.0%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified80.7%
Taylor expanded in B around -inf
Simplified60.7%
if -5.8000000000000004e-85 < B < 5.29999999999999989e-108Initial program 66.2%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified75.7%
Taylor expanded in B around inf
Simplified43.5%
Taylor expanded in C around inf
/-lowering-/.f6441.6%
Simplified41.6%
if 5.29999999999999989e-108 < B Initial program 54.2%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified79.3%
Taylor expanded in B around inf
Simplified50.4%
Final simplification50.8%
(FPCore (A B C)
:precision binary64
(if (<= B -1.1e-175)
(* (/ 180.0 PI) (atan 1.0))
(if (<= B 1.35e-98)
(* 180.0 (/ (atan 0.0) PI))
(* (/ 180.0 PI) (atan -1.0)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -1.1e-175) {
tmp = (180.0 / ((double) M_PI)) * atan(1.0);
} else if (B <= 1.35e-98) {
tmp = 180.0 * (atan(0.0) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(-1.0);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -1.1e-175) {
tmp = (180.0 / Math.PI) * Math.atan(1.0);
} else if (B <= 1.35e-98) {
tmp = 180.0 * (Math.atan(0.0) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(-1.0);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -1.1e-175: tmp = (180.0 / math.pi) * math.atan(1.0) elif B <= 1.35e-98: tmp = 180.0 * (math.atan(0.0) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(-1.0) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -1.1e-175) tmp = Float64(Float64(180.0 / pi) * atan(1.0)); elseif (B <= 1.35e-98) tmp = Float64(180.0 * Float64(atan(0.0) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(-1.0)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -1.1e-175) tmp = (180.0 / pi) * atan(1.0); elseif (B <= 1.35e-98) tmp = 180.0 * (atan(0.0) / pi); else tmp = (180.0 / pi) * atan(-1.0); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -1.1e-175], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[1.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.35e-98], N[(180.0 * N[(N[ArcTan[0.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[-1.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -1.1 \cdot 10^{-175}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} 1\\
\mathbf{elif}\;B \leq 1.35 \cdot 10^{-98}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} -1\\
\end{array}
\end{array}
if B < -1.1e-175Initial program 58.7%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified78.5%
Taylor expanded in B around -inf
Simplified52.6%
if -1.1e-175 < B < 1.3499999999999999e-98Initial program 61.7%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6459.8%
Applied egg-rr59.8%
Taylor expanded in A around -inf
distribute-lft1-inN/A
metadata-evalN/A
mul0-lft29.5%
Simplified29.5%
if 1.3499999999999999e-98 < B Initial program 56.8%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified81.8%
Taylor expanded in B around inf
Simplified52.7%
Final simplification46.1%
(FPCore (A B C) :precision binary64 (if (<= B 1.9e-105) (* 180.0 (/ (atan (+ 1.0 (/ C B))) PI)) (* (/ 180.0 PI) (atan -1.0))))
double code(double A, double B, double C) {
double tmp;
if (B <= 1.9e-105) {
tmp = 180.0 * (atan((1.0 + (C / B))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(-1.0);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 1.9e-105) {
tmp = 180.0 * (Math.atan((1.0 + (C / B))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(-1.0);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 1.9e-105: tmp = 180.0 * (math.atan((1.0 + (C / B))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(-1.0) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 1.9e-105) tmp = Float64(180.0 * Float64(atan(Float64(1.0 + Float64(C / B))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(-1.0)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 1.9e-105) tmp = 180.0 * (atan((1.0 + (C / B))) / pi); else tmp = (180.0 / pi) * atan(-1.0); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 1.9e-105], N[(180.0 * N[(N[ArcTan[N[(1.0 + N[(C / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[-1.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 1.9 \cdot 10^{-105}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(1 + \frac{C}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} -1\\
\end{array}
\end{array}
if B < 1.8999999999999999e-105Initial program 61.2%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6472.3%
Applied egg-rr72.3%
Taylor expanded in A around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6460.4%
Simplified60.4%
Taylor expanded in B around -inf
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6456.3%
Simplified56.3%
if 1.8999999999999999e-105 < B Initial program 54.2%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified79.3%
Taylor expanded in B around inf
Simplified50.4%
Final simplification54.4%
(FPCore (A B C) :precision binary64 (if (<= B 6.3e-99) (* 180.0 (/ (atan 0.0) PI)) (* (/ 180.0 PI) (atan -1.0))))
double code(double A, double B, double C) {
double tmp;
if (B <= 6.3e-99) {
tmp = 180.0 * (atan(0.0) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(-1.0);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= 6.3e-99) {
tmp = 180.0 * (Math.atan(0.0) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(-1.0);
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= 6.3e-99: tmp = 180.0 * (math.atan(0.0) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(-1.0) return tmp
function code(A, B, C) tmp = 0.0 if (B <= 6.3e-99) tmp = Float64(180.0 * Float64(atan(0.0) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(-1.0)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= 6.3e-99) tmp = 180.0 * (atan(0.0) / pi); else tmp = (180.0 / pi) * atan(-1.0); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, 6.3e-99], N[(180.0 * N[(N[ArcTan[0.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[-1.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 6.3 \cdot 10^{-99}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} -1\\
\end{array}
\end{array}
if B < 6.29999999999999992e-99Initial program 59.9%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6470.8%
Applied egg-rr70.8%
Taylor expanded in A around -inf
distribute-lft1-inN/A
metadata-evalN/A
mul0-lft15.6%
Simplified15.6%
if 6.29999999999999992e-99 < B Initial program 56.8%
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified81.8%
Taylor expanded in B around inf
Simplified52.7%
Final simplification26.9%
(FPCore (A B C) :precision binary64 (* 180.0 (/ (atan 0.0) PI)))
double code(double A, double B, double C) {
return 180.0 * (atan(0.0) / ((double) M_PI));
}
public static double code(double A, double B, double C) {
return 180.0 * (Math.atan(0.0) / Math.PI);
}
def code(A, B, C): return 180.0 * (math.atan(0.0) / math.pi)
function code(A, B, C) return Float64(180.0 * Float64(atan(0.0) / pi)) end
function tmp = code(A, B, C) tmp = 180.0 * (atan(0.0) / pi); end
code[A_, B_, C_] := N[(180.0 * N[(N[ArcTan[0.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
180 \cdot \frac{\tan^{-1} 0}{\pi}
\end{array}
Initial program 59.0%
sub-negN/A
distribute-lft-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
pow2N/A
+-commutativeN/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6474.1%
Applied egg-rr74.1%
Taylor expanded in A around -inf
distribute-lft1-inN/A
metadata-evalN/A
mul0-lft11.9%
Simplified11.9%
herbie shell --seed 2024139
(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)))