
(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}
Herbie found 14 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
(*
180.0
(/
(atan
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))
PI)))
(t_1 (atan (/ (- (- C A) (hypot (- A C) B)) B))))
(if (<= t_0 -0.2)
(/ (* t_1 180.0) PI)
(if (<= t_0 0.0)
(* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))
(* (/ t_1 PI) 180.0)))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
double t_1 = atan((((C - A) - hypot((A - C), B)) / B));
double tmp;
if (t_0 <= -0.2) {
tmp = (t_1 * 180.0) / ((double) M_PI);
} else if (t_0 <= 0.0) {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
} else {
tmp = (t_1 / ((double) M_PI)) * 180.0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
double t_1 = Math.atan((((C - A) - Math.hypot((A - C), B)) / B));
double tmp;
if (t_0 <= -0.2) {
tmp = (t_1 * 180.0) / Math.PI;
} else if (t_0 <= 0.0) {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
} else {
tmp = (t_1 / Math.PI) * 180.0;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi) t_1 = math.atan((((C - A) - math.hypot((A - C), B)) / B)) tmp = 0 if t_0 <= -0.2: tmp = (t_1 * 180.0) / math.pi elif t_0 <= 0.0: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) else: tmp = (t_1 / math.pi) * 180.0 return tmp
function code(A, B, C) t_0 = 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)) t_1 = atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B)) tmp = 0.0 if (t_0 <= -0.2) tmp = Float64(Float64(t_1 * 180.0) / pi); elseif (t_0 <= 0.0) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); else tmp = Float64(Float64(t_1 / pi) * 180.0); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); t_1 = atan((((C - A) - hypot((A - C), B)) / B)); tmp = 0.0; if (t_0 <= -0.2) tmp = (t_1 * 180.0) / pi; elseif (t_0 <= 0.0) tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); else tmp = (t_1 / pi) * 180.0; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = 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]}, Block[{t$95$1 = N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -0.2], N[(N[(t$95$1 * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$1 / Pi), $MachinePrecision] * 180.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 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}\\
t_1 := \tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\right)\\
\mathbf{if}\;t\_0 \leq -0.2:\\
\;\;\;\;\frac{t\_1 \cdot 180}{\pi}\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_1}{\pi} \cdot 180\\
\end{array}
\end{array}
if (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < -0.20000000000000001Initial program 60.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites87.1%
if -0.20000000000000001 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < 0.0Initial program 17.8%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6417.8
lift-pow.f64N/A
unpow2N/A
lower-*.f6417.8
Applied rewrites17.8%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f648.2
Applied rewrites8.2%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f649.2
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f649.2
Applied rewrites9.2%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6497.4
Applied rewrites97.4%
if 0.0 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) Initial program 59.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6459.0
Applied rewrites86.3%
(FPCore (A B C)
:precision binary64
(let* ((t_0
(*
180.0
(/
(atan
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))
PI)))
(t_1 (* (/ (atan (/ (- (- C A) (hypot (- A C) B)) B)) PI) 180.0)))
(if (<= t_0 -0.2)
t_1
(if (<= t_0 0.0) (* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI)) t_1))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
double t_1 = (atan((((C - A) - hypot((A - C), B)) / B)) / ((double) M_PI)) * 180.0;
double tmp;
if (t_0 <= -0.2) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
double t_1 = (Math.atan((((C - A) - Math.hypot((A - C), B)) / B)) / Math.PI) * 180.0;
double tmp;
if (t_0 <= -0.2) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
} else {
tmp = t_1;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi) t_1 = (math.atan((((C - A) - math.hypot((A - C), B)) / B)) / math.pi) * 180.0 tmp = 0 if t_0 <= -0.2: tmp = t_1 elif t_0 <= 0.0: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) else: tmp = t_1 return tmp
function code(A, B, C) t_0 = 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)) t_1 = Float64(Float64(atan(Float64(Float64(Float64(C - A) - hypot(Float64(A - C), B)) / B)) / pi) * 180.0) tmp = 0.0 if (t_0 <= -0.2) tmp = t_1; elseif (t_0 <= 0.0) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); else tmp = t_1; end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); t_1 = (atan((((C - A) - hypot((A - C), B)) / B)) / pi) * 180.0; tmp = 0.0; if (t_0 <= -0.2) tmp = t_1; elseif (t_0 <= 0.0) tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); else tmp = t_1; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = 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]}, Block[{t$95$1 = N[(N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision]}, If[LessEqual[t$95$0, -0.2], t$95$1, If[LessEqual[t$95$0, 0.0], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 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}\\
t_1 := \frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(A - C, B\right)}{B}\right)}{\pi} \cdot 180\\
\mathbf{if}\;t\_0 \leq -0.2:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < -0.20000000000000001 or 0.0 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) Initial program 59.8%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6459.8
Applied rewrites86.7%
if -0.20000000000000001 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < 0.0Initial program 17.8%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6417.8
lift-pow.f64N/A
unpow2N/A
lower-*.f6417.8
Applied rewrites17.8%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f648.2
Applied rewrites8.2%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f649.2
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f649.2
Applied rewrites9.2%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6497.4
Applied rewrites97.4%
(FPCore (A B C)
:precision binary64
(let* ((t_0
(*
180.0
(/
(atan
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))
PI))))
(if (<= t_0 -40.0)
(/ (* (atan (/ (- C (+ B A)) B)) 180.0) PI)
(if (<= t_0 0.05)
(* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))
(/ (* (atan (/ (- C (+ (* -1.0 B) A)) B)) 180.0) PI)))))
double code(double A, double B, double C) {
double t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / ((double) M_PI));
double tmp;
if (t_0 <= -40.0) {
tmp = (atan(((C - (B + A)) / B)) * 180.0) / ((double) M_PI);
} else if (t_0 <= 0.05) {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
} else {
tmp = (atan(((C - ((-1.0 * B) + A)) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = 180.0 * (Math.atan(((1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / Math.PI);
double tmp;
if (t_0 <= -40.0) {
tmp = (Math.atan(((C - (B + A)) / B)) * 180.0) / Math.PI;
} else if (t_0 <= 0.05) {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
} else {
tmp = (Math.atan(((C - ((-1.0 * B) + A)) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): t_0 = 180.0 * (math.atan(((1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / math.pi) tmp = 0 if t_0 <= -40.0: tmp = (math.atan(((C - (B + A)) / B)) * 180.0) / math.pi elif t_0 <= 0.05: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) else: tmp = (math.atan(((C - ((-1.0 * B) + A)) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) t_0 = 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)) tmp = 0.0 if (t_0 <= -40.0) tmp = Float64(Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) * 180.0) / pi); elseif (t_0 <= 0.05) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); else tmp = Float64(Float64(atan(Float64(Float64(C - Float64(Float64(-1.0 * B) + A)) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) t_0 = 180.0 * (atan(((1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / pi); tmp = 0.0; if (t_0 <= -40.0) tmp = (atan(((C - (B + A)) / B)) * 180.0) / pi; elseif (t_0 <= 0.05) tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); else tmp = (atan(((C - ((-1.0 * B) + A)) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = 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]}, If[LessEqual[t$95$0, -40.0], N[(N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[t$95$0, 0.05], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - N[(N[(-1.0 * B), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 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}\\
\mathbf{if}\;t\_0 \leq -40:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right) \cdot 180}{\pi}\\
\mathbf{elif}\;t\_0 \leq 0.05:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(-1 \cdot B + A\right)}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < -40Initial program 60.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites87.0%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites82.5%
Taylor expanded in B around inf
Applied rewrites77.1%
if -40 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) < 0.050000000000000003Initial program 18.0%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6418.0
lift-pow.f64N/A
unpow2N/A
lower-*.f6418.0
Applied rewrites18.0%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f648.4
Applied rewrites8.4%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f649.3
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f649.3
Applied rewrites9.3%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6495.5
Applied rewrites95.5%
if 0.050000000000000003 < (*.f64 #s(literal 180 binary64) (/.f64 (atan.f64 (*.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))))))) (PI.f64))) Initial program 59.3%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites86.2%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites81.9%
Taylor expanded in B around -inf
lower-*.f6476.0
Applied rewrites76.0%
(FPCore (A B C) :precision binary64 (if (<= C 6.5) (* (atan (/ (- (- C (hypot B (- A C))) A) B)) (/ 180.0 PI)) (* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))))
double code(double A, double B, double C) {
double tmp;
if (C <= 6.5) {
tmp = atan((((C - hypot(B, (A - C))) - A) / B)) * (180.0 / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 6.5) {
tmp = Math.atan((((C - Math.hypot(B, (A - C))) - A) / B)) * (180.0 / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 6.5: tmp = math.atan((((C - math.hypot(B, (A - C))) - A) / B)) * (180.0 / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 6.5) tmp = Float64(atan(Float64(Float64(Float64(C - hypot(B, Float64(A - C))) - A) / B)) * Float64(180.0 / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 6.5) tmp = atan((((C - hypot(B, (A - C))) - A) / B)) * (180.0 / pi); else tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 6.5], N[(N[ArcTan[N[(N[(N[(C - N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] - A), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * N[(180.0 / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 6.5:\\
\;\;\;\;\tan^{-1} \left(\frac{\left(C - \mathsf{hypot}\left(B, A - C\right)\right) - A}{B}\right) \cdot \frac{180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\end{array}
\end{array}
if C < 6.5Initial program 63.4%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6463.4
Applied rewrites84.5%
Applied rewrites84.6%
if 6.5 < C Initial program 25.9%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6425.9
lift-pow.f64N/A
unpow2N/A
lower-*.f6425.9
Applied rewrites25.9%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f648.7
Applied rewrites8.7%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f649.3
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f649.3
Applied rewrites9.3%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6471.2
Applied rewrites71.2%
(FPCore (A B C) :precision binary64 (if (<= C 6.5) (/ (* (atan (/ (- C (+ (hypot B A) A)) B)) 180.0) PI) (* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))))
double code(double A, double B, double C) {
double tmp;
if (C <= 6.5) {
tmp = (atan(((C - (hypot(B, A) + A)) / B)) * 180.0) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 6.5) {
tmp = (Math.atan(((C - (Math.hypot(B, A) + A)) / B)) * 180.0) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 6.5: tmp = (math.atan(((C - (math.hypot(B, A) + A)) / B)) * 180.0) / math.pi else: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 6.5) tmp = Float64(Float64(atan(Float64(Float64(C - Float64(hypot(B, A) + A)) / B)) * 180.0) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 6.5) tmp = (atan(((C - (hypot(B, A) + A)) / B)) * 180.0) / pi; else tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 6.5], N[(N[(N[ArcTan[N[(N[(C - N[(N[Sqrt[B ^ 2 + A ^ 2], $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 6.5:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(\mathsf{hypot}\left(B, A\right) + A\right)}{B}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\end{array}
\end{array}
if C < 6.5Initial program 63.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites84.5%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites79.7%
Taylor expanded in A around inf
Applied rewrites78.8%
if 6.5 < C Initial program 25.9%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6425.9
lift-pow.f64N/A
unpow2N/A
lower-*.f6425.9
Applied rewrites25.9%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f648.7
Applied rewrites8.7%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f649.3
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f649.3
Applied rewrites9.3%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6471.2
Applied rewrites71.2%
(FPCore (A B C)
:precision binary64
(if (<= B -2.8e+101)
(/ (* (atan (/ (- C (* -1.0 B)) B)) 180.0) PI)
(if (<= B 7.5e-83)
(* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))
(/ (* (atan (/ (- C (+ B A)) B)) 180.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.8e+101) {
tmp = (atan(((C - (-1.0 * B)) / B)) * 180.0) / ((double) M_PI);
} else if (B <= 7.5e-83) {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
} else {
tmp = (atan(((C - (B + A)) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.8e+101) {
tmp = (Math.atan(((C - (-1.0 * B)) / B)) * 180.0) / Math.PI;
} else if (B <= 7.5e-83) {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
} else {
tmp = (Math.atan(((C - (B + A)) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.8e+101: tmp = (math.atan(((C - (-1.0 * B)) / B)) * 180.0) / math.pi elif B <= 7.5e-83: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) else: tmp = (math.atan(((C - (B + A)) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.8e+101) tmp = Float64(Float64(atan(Float64(Float64(C - Float64(-1.0 * B)) / B)) * 180.0) / pi); elseif (B <= 7.5e-83) tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); else tmp = Float64(Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.8e+101) tmp = (atan(((C - (-1.0 * B)) / B)) * 180.0) / pi; elseif (B <= 7.5e-83) tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); else tmp = (atan(((C - (B + A)) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.8e+101], N[(N[(N[ArcTan[N[(N[(C - N[(-1.0 * B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 7.5e-83], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.8 \cdot 10^{+101}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - -1 \cdot B}{B}\right) \cdot 180}{\pi}\\
\mathbf{elif}\;B \leq 7.5 \cdot 10^{-83}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -2.79999999999999981e101Initial program 38.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites84.7%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites84.7%
Taylor expanded in B around -inf
lower-*.f6477.0
Applied rewrites77.0%
if -2.79999999999999981e101 < B < 7.4999999999999997e-83Initial program 60.3%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6460.3
lift-pow.f64N/A
unpow2N/A
lower-*.f6460.3
Applied rewrites60.3%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6431.8
Applied rewrites31.8%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f6432.2
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6432.2
Applied rewrites32.2%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6446.0
Applied rewrites46.0%
if 7.4999999999999997e-83 < B Initial program 52.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.8%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites77.0%
Taylor expanded in B around inf
Applied rewrites74.2%
(FPCore (A B C)
:precision binary64
(if (<= C 2.9e-299)
(/ (* (atan (/ (- C B) B)) 180.0) PI)
(if (<= C 1.9e-183)
(* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
(* (/ (atan (* -0.5 (/ B C))) PI) 180.0))))
double code(double A, double B, double C) {
double tmp;
if (C <= 2.9e-299) {
tmp = (atan(((C - B) / B)) * 180.0) / ((double) M_PI);
} else if (C <= 1.9e-183) {
tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
} else {
tmp = (atan((-0.5 * (B / C))) / ((double) M_PI)) * 180.0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 2.9e-299) {
tmp = (Math.atan(((C - B) / B)) * 180.0) / Math.PI;
} else if (C <= 1.9e-183) {
tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
} else {
tmp = (Math.atan((-0.5 * (B / C))) / Math.PI) * 180.0;
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 2.9e-299: tmp = (math.atan(((C - B) / B)) * 180.0) / math.pi elif C <= 1.9e-183: tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi) else: tmp = (math.atan((-0.5 * (B / C))) / math.pi) * 180.0 return tmp
function code(A, B, C) tmp = 0.0 if (C <= 2.9e-299) tmp = Float64(Float64(atan(Float64(Float64(C - B) / B)) * 180.0) / pi); elseif (C <= 1.9e-183) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi)); else tmp = Float64(Float64(atan(Float64(-0.5 * Float64(B / C))) / pi) * 180.0); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 2.9e-299) tmp = (atan(((C - B) / B)) * 180.0) / pi; elseif (C <= 1.9e-183) tmp = 180.0 * (atan((0.5 * (B / A))) / pi); else tmp = (atan((-0.5 * (B / C))) / pi) * 180.0; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 2.9e-299], N[(N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[C, 1.9e-183], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 2.9 \cdot 10^{-299}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - B}{B}\right) \cdot 180}{\pi}\\
\mathbf{elif}\;C \leq 1.9 \cdot 10^{-183}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi} \cdot 180\\
\end{array}
\end{array}
if C < 2.90000000000000026e-299Initial program 68.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites88.8%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites84.3%
Taylor expanded in B around inf
Applied rewrites58.4%
if 2.90000000000000026e-299 < C < 1.8999999999999998e-183Initial program 57.1%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6457.1
lift-pow.f64N/A
unpow2N/A
lower-*.f6457.1
Applied rewrites57.1%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6431.1
Applied rewrites31.1%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f6431.3
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6431.3
Applied rewrites31.3%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6430.3
Applied rewrites30.3%
if 1.8999999999999998e-183 < C Initial program 34.9%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6434.9
Applied rewrites62.0%
Applied rewrites46.6%
Taylor expanded in C around inf
lower-*.f64N/A
lower-/.f6453.6
Applied rewrites53.6%
(FPCore (A B C)
:precision binary64
(if (<= B -7.5e+28)
(/ (* (atan 1.0) 180.0) PI)
(if (<= B 9e-179)
(* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
(/ (* (atan (/ (- C B) B)) 180.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -7.5e+28) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else if (B <= 9e-179) {
tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
} else {
tmp = (atan(((C - B) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -7.5e+28) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else if (B <= 9e-179) {
tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
} else {
tmp = (Math.atan(((C - B) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -7.5e+28: tmp = (math.atan(1.0) * 180.0) / math.pi elif B <= 9e-179: tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi) else: tmp = (math.atan(((C - B) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (B <= -7.5e+28) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); elseif (B <= 9e-179) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi)); else tmp = Float64(Float64(atan(Float64(Float64(C - B) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -7.5e+28) tmp = (atan(1.0) * 180.0) / pi; elseif (B <= 9e-179) tmp = 180.0 * (atan((0.5 * (B / A))) / pi); else tmp = (atan(((C - B) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -7.5e+28], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 9e-179], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -7.5 \cdot 10^{+28}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{elif}\;B \leq 9 \cdot 10^{-179}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - B}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -7.4999999999999998e28Initial program 45.7%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites79.8%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites79.8%
Taylor expanded in B around -inf
Applied rewrites63.0%
if -7.4999999999999998e28 < B < 8.99999999999999984e-179Initial program 60.3%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6460.3
lift-pow.f64N/A
unpow2N/A
lower-*.f6460.3
Applied rewrites60.3%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6430.9
Applied rewrites30.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f6431.4
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6431.4
Applied rewrites31.4%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6431.6
Applied rewrites31.6%
if 8.99999999999999984e-179 < B Initial program 53.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites76.9%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites74.7%
Taylor expanded in B around inf
Applied rewrites60.5%
(FPCore (A B C)
:precision binary64
(if (<= B -2.9e-86)
(/ (* (atan 1.0) 180.0) PI)
(if (<= B 2.5e-203)
(/ (* (atan (/ (- C C) B)) 180.0) PI)
(/ (* (atan (/ (- C B) B)) 180.0) PI))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-86) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else if (B <= 2.5e-203) {
tmp = (atan(((C - C) / B)) * 180.0) / ((double) M_PI);
} else {
tmp = (atan(((C - B) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-86) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else if (B <= 2.5e-203) {
tmp = (Math.atan(((C - C) / B)) * 180.0) / Math.PI;
} else {
tmp = (Math.atan(((C - B) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.9e-86: tmp = (math.atan(1.0) * 180.0) / math.pi elif B <= 2.5e-203: tmp = (math.atan(((C - C) / B)) * 180.0) / math.pi else: tmp = (math.atan(((C - B) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.9e-86) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); elseif (B <= 2.5e-203) tmp = Float64(Float64(atan(Float64(Float64(C - C) / B)) * 180.0) / pi); else tmp = Float64(Float64(atan(Float64(Float64(C - B) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.9e-86) tmp = (atan(1.0) * 180.0) / pi; elseif (B <= 2.5e-203) tmp = (atan(((C - C) / B)) * 180.0) / pi; else tmp = (atan(((C - B) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.9e-86], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 2.5e-203], N[(N[(N[ArcTan[N[(N[(C - C), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.9 \cdot 10^{-86}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{elif}\;B \leq 2.5 \cdot 10^{-203}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - C}{B}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - B}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -2.8999999999999999e-86Initial program 51.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites76.3%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites75.9%
Taylor expanded in B around -inf
Applied rewrites54.1%
if -2.8999999999999999e-86 < B < 2.5000000000000001e-203Initial program 59.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites79.9%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites66.3%
Taylor expanded in A around -inf
Applied rewrites29.5%
if 2.5000000000000001e-203 < B Initial program 52.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites76.6%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites74.1%
Taylor expanded in B around inf
Applied rewrites59.2%
(FPCore (A B C) :precision binary64 (if (<= C 3.1e-125) (/ (* (atan (/ (- C (+ B A)) B)) 180.0) PI) (* 180.0 (/ (atan (* -0.5 (/ B (- C A)))) PI))))
double code(double A, double B, double C) {
double tmp;
if (C <= 3.1e-125) {
tmp = (atan(((C - (B + A)) / B)) * 180.0) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 3.1e-125) {
tmp = (Math.atan(((C - (B + A)) / B)) * 180.0) / Math.PI;
} else {
tmp = 180.0 * (Math.atan((-0.5 * (B / (C - A)))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 3.1e-125: tmp = (math.atan(((C - (B + A)) / B)) * 180.0) / math.pi else: tmp = 180.0 * (math.atan((-0.5 * (B / (C - A)))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (C <= 3.1e-125) tmp = Float64(Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) * 180.0) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(B / Float64(C - A)))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 3.1e-125) tmp = (atan(((C - (B + A)) / B)) * 180.0) / pi; else tmp = 180.0 * (atan((-0.5 * (B / (C - A)))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 3.1e-125], N[(N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(B / N[(C - A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 3.1 \cdot 10^{-125}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C - A}\right)}{\pi}\\
\end{array}
\end{array}
if C < 3.10000000000000013e-125Initial program 65.7%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites86.9%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites81.9%
Taylor expanded in B around inf
Applied rewrites61.9%
if 3.10000000000000013e-125 < C Initial program 32.2%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
lower-fma.f6432.2
lift-pow.f64N/A
unpow2N/A
lower-*.f6432.2
Applied rewrites32.2%
lift--.f64N/A
flip3--N/A
lower-/.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f64N/A
+-commutativeN/A
distribute-rgt-outN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6416.6
Applied rewrites16.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
difference-cubesN/A
lift-*.f64N/A
distribute-rgt-inN/A
lift-+.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift--.f64N/A
lower-*.f6417.0
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6417.0
Applied rewrites17.0%
Taylor expanded in B around 0
lower-*.f64N/A
lower-/.f64N/A
lower--.f6463.3
Applied rewrites63.3%
(FPCore (A B C) :precision binary64 (if (<= C 1.18e-26) (/ (* (atan (/ (- C (+ B A)) B)) 180.0) PI) (* (/ (atan (* -0.5 (/ B C))) PI) 180.0)))
double code(double A, double B, double C) {
double tmp;
if (C <= 1.18e-26) {
tmp = (atan(((C - (B + A)) / B)) * 180.0) / ((double) M_PI);
} else {
tmp = (atan((-0.5 * (B / C))) / ((double) M_PI)) * 180.0;
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 1.18e-26) {
tmp = (Math.atan(((C - (B + A)) / B)) * 180.0) / Math.PI;
} else {
tmp = (Math.atan((-0.5 * (B / C))) / Math.PI) * 180.0;
}
return tmp;
}
def code(A, B, C): tmp = 0 if C <= 1.18e-26: tmp = (math.atan(((C - (B + A)) / B)) * 180.0) / math.pi else: tmp = (math.atan((-0.5 * (B / C))) / math.pi) * 180.0 return tmp
function code(A, B, C) tmp = 0.0 if (C <= 1.18e-26) tmp = Float64(Float64(atan(Float64(Float64(C - Float64(B + A)) / B)) * 180.0) / pi); else tmp = Float64(Float64(atan(Float64(-0.5 * Float64(B / C))) / pi) * 180.0); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 1.18e-26) tmp = (atan(((C - (B + A)) / B)) * 180.0) / pi; else tmp = (atan((-0.5 * (B / C))) / pi) * 180.0; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[C, 1.18e-26], N[(N[(N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 1.18 \cdot 10^{-26}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(-0.5 \cdot \frac{B}{C}\right)}{\pi} \cdot 180\\
\end{array}
\end{array}
if C < 1.17999999999999996e-26Initial program 63.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites85.1%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites80.2%
Taylor expanded in B around inf
Applied rewrites59.9%
if 1.17999999999999996e-26 < C Initial program 27.4%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6427.4
Applied rewrites56.9%
Applied rewrites36.7%
Taylor expanded in C around inf
lower-*.f64N/A
lower-/.f6463.3
Applied rewrites63.3%
(FPCore (A B C) :precision binary64 (if (<= B -2.2e-19) (/ (* (atan 1.0) 180.0) PI) (/ (* (atan (/ (- C B) B)) 180.0) PI)))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.2e-19) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else {
tmp = (atan(((C - B) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.2e-19) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else {
tmp = (Math.atan(((C - B) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.2e-19: tmp = (math.atan(1.0) * 180.0) / math.pi else: tmp = (math.atan(((C - B) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.2e-19) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); else tmp = Float64(Float64(atan(Float64(Float64(C - B) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.2e-19) tmp = (atan(1.0) * 180.0) / pi; else tmp = (atan(((C - B) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.2e-19], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.2 \cdot 10^{-19}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - B}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -2.1999999999999998e-19Initial program 49.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites78.3%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites78.3%
Taylor expanded in B around -inf
Applied rewrites59.2%
if -2.1999999999999998e-19 < B Initial program 55.8%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.0%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites70.5%
Taylor expanded in B around inf
Applied rewrites48.5%
(FPCore (A B C) :precision binary64 (if (<= B -1.4e-302) (/ (* (atan 1.0) 180.0) PI) (/ (* (atan -1.0) 180.0) PI)))
double code(double A, double B, double C) {
double tmp;
if (B <= -1.4e-302) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else {
tmp = (atan(-1.0) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -1.4e-302) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else {
tmp = (Math.atan(-1.0) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -1.4e-302: tmp = (math.atan(1.0) * 180.0) / math.pi else: tmp = (math.atan(-1.0) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (B <= -1.4e-302) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); else tmp = Float64(Float64(atan(-1.0) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -1.4e-302) tmp = (atan(1.0) * 180.0) / pi; else tmp = (atan(-1.0) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -1.4e-302], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[-1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -1.4 \cdot 10^{-302}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} -1 \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -1.4e-302Initial program 53.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites76.7%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites72.5%
Taylor expanded in B around -inf
Applied rewrites40.8%
if -1.4e-302 < B Initial program 54.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites78.0%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites72.9%
Taylor expanded in B around inf
Applied rewrites39.4%
(FPCore (A B C) :precision binary64 (/ (* (atan -1.0) 180.0) PI))
double code(double A, double B, double C) {
return (atan(-1.0) * 180.0) / ((double) M_PI);
}
public static double code(double A, double B, double C) {
return (Math.atan(-1.0) * 180.0) / Math.PI;
}
def code(A, B, C): return (math.atan(-1.0) * 180.0) / math.pi
function code(A, B, C) return Float64(Float64(atan(-1.0) * 180.0) / pi) end
function tmp = code(A, B, C) tmp = (atan(-1.0) * 180.0) / pi; end
code[A_, B_, C_] := N[(N[(N[ArcTan[-1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]
\begin{array}{l}
\\
\frac{\tan^{-1} -1 \cdot 180}{\pi}
\end{array}
Initial program 54.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.4%
lift--.f64N/A
lift--.f64N/A
associate--l-N/A
lower--.f64N/A
lift-hypot.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-sqrt.f64N/A
lift-*.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
lift--.f64N/A
sub-negate2N/A
lift--.f64N/A
sqr-neg-revN/A
+-commutativeN/A
lift-fma.f64N/A
Applied rewrites72.7%
Taylor expanded in B around inf
Applied rewrites20.8%
herbie shell --seed 2025111
(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)))