
(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}
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<=
(*
180.0
(/
(atan
(*
(/ 1.0 B_m)
(- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))))
PI))
-40.0)
(* 180.0 (/ (atan (* (/ 1.0 B_m) (- (- C A) (hypot (- A C) B_m)))) PI))
(/ (* 180.0 (atan (* (/ B_m A) 0.5))) PI))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if ((180.0 * (atan(((1.0 / B_m) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))))) / ((double) M_PI))) <= -40.0) {
tmp = 180.0 * (atan(((1.0 / B_m) * ((C - A) - hypot((A - C), B_m)))) / ((double) M_PI));
} else {
tmp = (180.0 * atan(((B_m / A) * 0.5))) / ((double) M_PI);
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if ((180.0 * (Math.atan(((1.0 / B_m) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B_m, 2.0)))))) / Math.PI)) <= -40.0) {
tmp = 180.0 * (Math.atan(((1.0 / B_m) * ((C - A) - Math.hypot((A - C), B_m)))) / Math.PI);
} else {
tmp = (180.0 * Math.atan(((B_m / A) * 0.5))) / Math.PI;
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if (180.0 * (math.atan(((1.0 / B_m) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B_m, 2.0)))))) / math.pi)) <= -40.0: tmp = 180.0 * (math.atan(((1.0 / B_m) * ((C - A) - math.hypot((A - C), B_m)))) / math.pi) else: tmp = (180.0 * math.atan(((B_m / A) * 0.5))) / math.pi return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B_m) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))))) / pi)) <= -40.0) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B_m) * Float64(Float64(C - A) - hypot(Float64(A - C), B_m)))) / pi)); else tmp = Float64(Float64(180.0 * atan(Float64(Float64(B_m / A) * 0.5))) / pi); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if ((180.0 * (atan(((1.0 / B_m) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B_m ^ 2.0)))))) / pi)) <= -40.0) tmp = 180.0 * (atan(((1.0 / B_m) * ((C - A) - hypot((A - C), B_m)))) / pi); else tmp = (180.0 * atan(((B_m / A) * 0.5))) / pi; end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B$95$m), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], -40.0], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B$95$m), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B\_m} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right)\right)}{\pi} \leq -40:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B\_m} \cdot \left(\left(C - A\right) - \mathsf{hypot}\left(A - C, B\_m\right)\right)\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}{\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 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.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))) Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.9%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -8e+101)
(/ (* 180.0 (atan (/ (* 0.5 (fma (/ C A) B_m B_m)) A))) PI)
(* 180.0 (/ (atan (* (/ 1.0 B_m) (- C (hypot (- A C) B_m)))) PI)))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -8e+101) {
tmp = (180.0 * atan(((0.5 * fma((C / A), B_m, B_m)) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(((1.0 / B_m) * (C - hypot((A - C), B_m)))) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -8e+101) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(Float64(C / A), B_m, B_m)) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B_m) * Float64(C - hypot(Float64(A - C), B_m)))) / pi)); end return Float64(B_s * tmp) end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -8e+101], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(N[(C / A), $MachinePrecision] * B$95$m + B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B$95$m), $MachinePrecision] * N[(C - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -8 \cdot 10^{+101}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(\frac{C}{A}, B\_m, B\_m\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B\_m} \cdot \left(C - \mathsf{hypot}\left(A - C, B\_m\right)\right)\right)}{\pi}\\
\end{array}
\end{array}
if A < -7.9999999999999998e101Initial program 54.3%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6433.2
Applied rewrites33.2%
Applied rewrites33.3%
if -7.9999999999999998e101 < A Initial program 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.1%
Taylor expanded in A around 0
Applied rewrites72.4%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -8e+101)
(/ (* 180.0 (atan (/ (* 0.5 (fma (/ C A) B_m B_m)) A))) PI)
(if (<= A 1.7e+38)
(* 180.0 (/ (atan (* (/ 1.0 B_m) (- C (hypot (- C) B_m)))) PI))
(* 180.0 (/ (atan (- (/ (- A) B_m) 1.0)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -8e+101) {
tmp = (180.0 * atan(((0.5 * fma((C / A), B_m, B_m)) / A))) / ((double) M_PI);
} else if (A <= 1.7e+38) {
tmp = 180.0 * (atan(((1.0 / B_m) * (C - hypot(-C, B_m)))) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((-A / B_m) - 1.0)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -8e+101) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(Float64(C / A), B_m, B_m)) / A))) / pi); elseif (A <= 1.7e+38) tmp = Float64(180.0 * Float64(atan(Float64(Float64(1.0 / B_m) * Float64(C - hypot(Float64(-C), B_m)))) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) / B_m) - 1.0)) / pi)); end return Float64(B_s * tmp) end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -8e+101], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(N[(C / A), $MachinePrecision] * B$95$m + B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.7e+38], N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / B$95$m), $MachinePrecision] * N[(C - N[Sqrt[(-C) ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[((-A) / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -8 \cdot 10^{+101}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(\frac{C}{A}, B\_m, B\_m\right)}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.7 \cdot 10^{+38}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{B\_m} \cdot \left(C - \mathsf{hypot}\left(-C, B\_m\right)\right)\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B\_m} - 1\right)}{\pi}\\
\end{array}
\end{array}
if A < -7.9999999999999998e101Initial program 54.3%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6433.2
Applied rewrites33.2%
Applied rewrites33.3%
if -7.9999999999999998e101 < A < 1.69999999999999998e38Initial program 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.1%
Taylor expanded in A around 0
Applied rewrites72.4%
Taylor expanded in A around 0
mul-1-negN/A
lower-neg.f6464.4
Applied rewrites64.4%
if 1.69999999999999998e38 < A Initial program 54.3%
Taylor expanded in C around 0
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6444.9
Applied rewrites44.9%
Taylor expanded in B around inf
lower--.f64N/A
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f6456.0
Applied rewrites56.0%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -3.9e+65)
(* 180.0 (/ 1.0 (/ PI (atan (* (/ B_m A) 0.5)))))
(if (<= A 0.00046)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(* 180.0 (/ (atan (- (/ (- A) B_m) 1.0)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = 180.0 * (1.0 / (((double) M_PI) / atan(((B_m / A) * 0.5))));
} else if (A <= 0.00046) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((-A / B_m) - 1.0)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = 180.0 * (1.0 / (Math.PI / Math.atan(((B_m / A) * 0.5))));
} else if (A <= 0.00046) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((-A / B_m) - 1.0)) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -3.9e+65: tmp = 180.0 * (1.0 / (math.pi / math.atan(((B_m / A) * 0.5)))) elif A <= 0.00046: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = 180.0 * (math.atan(((-A / B_m) - 1.0)) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -3.9e+65) tmp = Float64(180.0 * Float64(1.0 / Float64(pi / atan(Float64(Float64(B_m / A) * 0.5))))); elseif (A <= 0.00046) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) / B_m) - 1.0)) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -3.9e+65) tmp = 180.0 * (1.0 / (pi / atan(((B_m / A) * 0.5)))); elseif (A <= 0.00046) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = 180.0 * (atan(((-A / B_m) - 1.0)) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -3.9e+65], N[(180.0 * N[(1.0 / N[(Pi / N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 0.00046], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[((-A) / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;180 \cdot \frac{1}{\frac{\pi}{\tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}}\\
\mathbf{elif}\;A \leq 0.00046:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B\_m} - 1\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.8999999999999998e65Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-/.f64N/A
div-flipN/A
lower-/.f64N/A
lower-/.f6425.9
pow225.9
pow225.9
Applied rewrites25.9%
if -3.8999999999999998e65 < A < 4.6000000000000001e-4Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 4.6000000000000001e-4 < A Initial program 54.3%
Taylor expanded in C around 0
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6444.9
Applied rewrites44.9%
Taylor expanded in B around inf
lower--.f64N/A
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f6456.0
Applied rewrites56.0%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -3.9e+65)
(/ (* 180.0 (atan (* (/ B_m A) 0.5))) PI)
(if (<= A 0.00046)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(* 180.0 (/ (atan (- (/ (- A) B_m) 1.0)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * atan(((B_m / A) * 0.5))) / ((double) M_PI);
} else if (A <= 0.00046) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((-A / B_m) - 1.0)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * Math.atan(((B_m / A) * 0.5))) / Math.PI;
} else if (A <= 0.00046) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((-A / B_m) - 1.0)) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -3.9e+65: tmp = (180.0 * math.atan(((B_m / A) * 0.5))) / math.pi elif A <= 0.00046: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = 180.0 * (math.atan(((-A / B_m) - 1.0)) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -3.9e+65) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B_m / A) * 0.5))) / pi); elseif (A <= 0.00046) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(-A) / B_m) - 1.0)) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -3.9e+65) tmp = (180.0 * atan(((B_m / A) * 0.5))) / pi; elseif (A <= 0.00046) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = 180.0 * (atan(((-A / B_m) - 1.0)) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -3.9e+65], N[(N[(180.0 * N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 0.00046], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[((-A) / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}{\pi}\\
\mathbf{elif}\;A \leq 0.00046:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{-A}{B\_m} - 1\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.8999999999999998e65Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.9%
if -3.8999999999999998e65 < A < 4.6000000000000001e-4Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 4.6000000000000001e-4 < A Initial program 54.3%
Taylor expanded in C around 0
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6444.9
Applied rewrites44.9%
Taylor expanded in B around inf
lower--.f64N/A
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f6456.0
Applied rewrites56.0%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -3.9e+65)
(/ (* 180.0 (atan (* (/ B_m A) 0.5))) PI)
(if (<= A 0.00046)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(/ (* 180.0 (atan (- (/ (- A) B_m) 1.0))) PI)))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * atan(((B_m / A) * 0.5))) / ((double) M_PI);
} else if (A <= 0.00046) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = (180.0 * atan(((-A / B_m) - 1.0))) / ((double) M_PI);
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * Math.atan(((B_m / A) * 0.5))) / Math.PI;
} else if (A <= 0.00046) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = (180.0 * Math.atan(((-A / B_m) - 1.0))) / Math.PI;
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -3.9e+65: tmp = (180.0 * math.atan(((B_m / A) * 0.5))) / math.pi elif A <= 0.00046: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = (180.0 * math.atan(((-A / B_m) - 1.0))) / math.pi return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -3.9e+65) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B_m / A) * 0.5))) / pi); elseif (A <= 0.00046) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(Float64(180.0 * atan(Float64(Float64(Float64(-A) / B_m) - 1.0))) / pi); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -3.9e+65) tmp = (180.0 * atan(((B_m / A) * 0.5))) / pi; elseif (A <= 0.00046) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = (180.0 * atan(((-A / B_m) - 1.0))) / pi; end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -3.9e+65], N[(N[(180.0 * N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 0.00046], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[N[(N[((-A) / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}{\pi}\\
\mathbf{elif}\;A \leq 0.00046:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{-A}{B\_m} - 1\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.8999999999999998e65Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.9%
if -3.8999999999999998e65 < A < 4.6000000000000001e-4Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 4.6000000000000001e-4 < A Initial program 54.3%
Taylor expanded in C around 0
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6444.9
Applied rewrites44.9%
Taylor expanded in B around inf
lower--.f64N/A
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f6456.0
Applied rewrites56.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites56.0%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -5e+58)
(/ (* 180.0 (atan (/ (* 0.5 (fma (/ C A) B_m B_m)) A))) PI)
(* 180.0 (/ (atan (- (- (/ C B_m) 1.0) (/ A B_m))) PI)))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -5e+58) {
tmp = (180.0 * atan(((0.5 * fma((C / A), B_m, B_m)) / A))) / ((double) M_PI);
} else {
tmp = 180.0 * (atan((((C / B_m) - 1.0) - (A / B_m))) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -5e+58) tmp = Float64(Float64(180.0 * atan(Float64(Float64(0.5 * fma(Float64(C / A), B_m, B_m)) / A))) / pi); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C / B_m) - 1.0) - Float64(A / B_m))) / pi)); end return Float64(B_s * tmp) end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -5e+58], N[(N[(180.0 * N[ArcTan[N[(N[(0.5 * N[(N[(C / A), $MachinePrecision] * B$95$m + B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision] - N[(A / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -5 \cdot 10^{+58}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(\frac{C}{A}, B\_m, B\_m\right)}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\left(\frac{C}{B\_m} - 1\right) - \frac{A}{B\_m}\right)}{\pi}\\
\end{array}
\end{array}
if A < -4.99999999999999986e58Initial program 54.3%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6433.2
Applied rewrites33.2%
Applied rewrites33.3%
if -4.99999999999999986e58 < A Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -5e+58)
(* 180.0 (/ 1.0 (/ PI (atan (* (/ B_m A) 0.5)))))
(* 180.0 (/ (atan (- (- (/ C B_m) 1.0) (/ A B_m))) PI)))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -5e+58) {
tmp = 180.0 * (1.0 / (((double) M_PI) / atan(((B_m / A) * 0.5))));
} else {
tmp = 180.0 * (atan((((C / B_m) - 1.0) - (A / B_m))) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -5e+58) {
tmp = 180.0 * (1.0 / (Math.PI / Math.atan(((B_m / A) * 0.5))));
} else {
tmp = 180.0 * (Math.atan((((C / B_m) - 1.0) - (A / B_m))) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -5e+58: tmp = 180.0 * (1.0 / (math.pi / math.atan(((B_m / A) * 0.5)))) else: tmp = 180.0 * (math.atan((((C / B_m) - 1.0) - (A / B_m))) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -5e+58) tmp = Float64(180.0 * Float64(1.0 / Float64(pi / atan(Float64(Float64(B_m / A) * 0.5))))); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(Float64(C / B_m) - 1.0) - Float64(A / B_m))) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -5e+58) tmp = 180.0 * (1.0 / (pi / atan(((B_m / A) * 0.5)))); else tmp = 180.0 * (atan((((C / B_m) - 1.0) - (A / B_m))) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -5e+58], N[(180.0 * N[(1.0 / N[(Pi / N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision] - N[(A / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -5 \cdot 10^{+58}:\\
\;\;\;\;180 \cdot \frac{1}{\frac{\pi}{\tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\left(\frac{C}{B\_m} - 1\right) - \frac{A}{B\_m}\right)}{\pi}\\
\end{array}
\end{array}
if A < -4.99999999999999986e58Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-/.f64N/A
div-flipN/A
lower-/.f64N/A
lower-/.f6425.9
pow225.9
pow225.9
Applied rewrites25.9%
if -4.99999999999999986e58 < A Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -3.9e+65)
(/ (* 180.0 (atan (* (/ B_m A) 0.5))) PI)
(if (<= A 2.2e+139)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(* 180.0 (/ (atan (/ (- C A) B_m)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * atan(((B_m / A) * 0.5))) / ((double) M_PI);
} else if (A <= 2.2e+139) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - A) / B_m)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (180.0 * Math.atan(((B_m / A) * 0.5))) / Math.PI;
} else if (A <= 2.2e+139) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - A) / B_m)) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -3.9e+65: tmp = (180.0 * math.atan(((B_m / A) * 0.5))) / math.pi elif A <= 2.2e+139: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = 180.0 * (math.atan(((C - A) / B_m)) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -3.9e+65) tmp = Float64(Float64(180.0 * atan(Float64(Float64(B_m / A) * 0.5))) / pi); elseif (A <= 2.2e+139) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - A) / B_m)) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -3.9e+65) tmp = (180.0 * atan(((B_m / A) * 0.5))) / pi; elseif (A <= 2.2e+139) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = 180.0 * (atan(((C - A) / B_m)) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -3.9e+65], N[(N[(180.0 * N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 2.2e+139], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - A), $MachinePrecision] / B$95$m), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}{\pi}\\
\mathbf{elif}\;A \leq 2.2 \cdot 10^{+139}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B\_m}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.8999999999999998e65Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.9%
if -3.8999999999999998e65 < A < 2.1999999999999999e139Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 2.1999999999999999e139 < A Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in B around 0
lower-/.f64N/A
lower--.f6434.9
Applied rewrites34.9%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -3.9e+65)
(* (/ (atan (* (/ B_m A) 0.5)) PI) 180.0)
(if (<= A 2.2e+139)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(* 180.0 (/ (atan (/ (- C A) B_m)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (atan(((B_m / A) * 0.5)) / ((double) M_PI)) * 180.0;
} else if (A <= 2.2e+139) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - A) / B_m)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -3.9e+65) {
tmp = (Math.atan(((B_m / A) * 0.5)) / Math.PI) * 180.0;
} else if (A <= 2.2e+139) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - A) / B_m)) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -3.9e+65: tmp = (math.atan(((B_m / A) * 0.5)) / math.pi) * 180.0 elif A <= 2.2e+139: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = 180.0 * (math.atan(((C - A) / B_m)) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -3.9e+65) tmp = Float64(Float64(atan(Float64(Float64(B_m / A) * 0.5)) / pi) * 180.0); elseif (A <= 2.2e+139) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - A) / B_m)) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -3.9e+65) tmp = (atan(((B_m / A) * 0.5)) / pi) * 180.0; elseif (A <= 2.2e+139) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = 180.0 * (atan(((C - A) / B_m)) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -3.9e+65], N[(N[(N[ArcTan[N[(N[(B$95$m / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision], If[LessEqual[A, 2.2e+139], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - A), $MachinePrecision] / B$95$m), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.9 \cdot 10^{+65}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{B\_m}{A} \cdot 0.5\right)}{\pi} \cdot 180\\
\mathbf{elif}\;A \leq 2.2 \cdot 10^{+139}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B\_m}\right)}{\pi}\\
\end{array}
\end{array}
if A < -3.8999999999999998e65Initial program 54.3%
Taylor expanded in A around -inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.9
Applied rewrites25.9%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6425.9
pow225.9
pow225.9
Applied rewrites25.9%
if -3.8999999999999998e65 < A < 2.1999999999999999e139Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 2.1999999999999999e139 < A Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in B around 0
lower-/.f64N/A
lower--.f6434.9
Applied rewrites34.9%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= A -5e+205)
(/ (* 180.0 (atan 0.0)) PI)
(if (<= A 2.2e+139)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(* 180.0 (/ (atan (/ (- C A) B_m)) PI))))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -5e+205) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else if (A <= 2.2e+139) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = 180.0 * (atan(((C - A) / B_m)) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (A <= -5e+205) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else if (A <= 2.2e+139) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = 180.0 * (Math.atan(((C - A) / B_m)) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if A <= -5e+205: tmp = (180.0 * math.atan(0.0)) / math.pi elif A <= 2.2e+139: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = 180.0 * (math.atan(((C - A) / B_m)) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (A <= -5e+205) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); elseif (A <= 2.2e+139) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(Float64(C - A) / B_m)) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (A <= -5e+205) tmp = (180.0 * atan(0.0)) / pi; elseif (A <= 2.2e+139) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = 180.0 * (atan(((C - A) / B_m)) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[A, -5e+205], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 2.2e+139], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(N[(C - A), $MachinePrecision] / B$95$m), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;A \leq -5 \cdot 10^{+205}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{elif}\;A \leq 2.2 \cdot 10^{+139}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C - A}{B\_m}\right)}{\pi}\\
\end{array}
\end{array}
if A < -5.0000000000000002e205Initial program 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.1%
Taylor expanded in C around inf
associate-*r/N/A
*-commutativeN/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
distribute-rgt1-inN/A
lower-/.f64N/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lft13.1
Applied rewrites13.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6413.1
lift-/.f64N/A
div013.1
Applied rewrites13.1%
if -5.0000000000000002e205 < A < 2.1999999999999999e139Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 2.1999999999999999e139 < A Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in B around 0
lower-/.f64N/A
lower--.f6434.9
Applied rewrites34.9%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= C 9.2e+188)
(* 180.0 (/ (atan (- (/ C B_m) 1.0)) PI))
(/ (* 180.0 (atan 0.0)) PI))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (C <= 9.2e+188) {
tmp = 180.0 * (atan(((C / B_m) - 1.0)) / ((double) M_PI));
} else {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (C <= 9.2e+188) {
tmp = 180.0 * (Math.atan(((C / B_m) - 1.0)) / Math.PI);
} else {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if C <= 9.2e+188: tmp = 180.0 * (math.atan(((C / B_m) - 1.0)) / math.pi) else: tmp = (180.0 * math.atan(0.0)) / math.pi return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (C <= 9.2e+188) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / B_m) - 1.0)) / pi)); else tmp = Float64(Float64(180.0 * atan(0.0)) / pi); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (C <= 9.2e+188) tmp = 180.0 * (atan(((C / B_m) - 1.0)) / pi); else tmp = (180.0 * atan(0.0)) / pi; end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[C, 9.2e+188], N[(180.0 * N[(N[ArcTan[N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;C \leq 9.2 \cdot 10^{+188}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{B\_m} - 1\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\end{array}
\end{array}
if C < 9.20000000000000046e188Initial program 54.3%
Taylor expanded in B around inf
associate--r+N/A
lower--.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6465.4
Applied rewrites65.4%
Taylor expanded in A around 0
lift-/.f64N/A
lift--.f6456.5
Applied rewrites56.5%
if 9.20000000000000046e188 < C Initial program 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.1%
Taylor expanded in C around inf
associate-*r/N/A
*-commutativeN/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
distribute-rgt1-inN/A
lower-/.f64N/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lft13.1
Applied rewrites13.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6413.1
lift-/.f64N/A
div013.1
Applied rewrites13.1%
B\_m = (fabs.f64 B)
B\_s = (copysign.f64 #s(literal 1 binary64) B)
(FPCore (B_s A B_m C)
:precision binary64
(*
B_s
(if (<= B_m 3.55e-152)
(/ (* 180.0 (atan 0.0)) PI)
(* 180.0 (/ (atan -1.0) PI)))))B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
double tmp;
if (B_m <= 3.55e-152) {
tmp = (180.0 * atan(0.0)) / ((double) M_PI);
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return B_s * tmp;
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
double tmp;
if (B_m <= 3.55e-152) {
tmp = (180.0 * Math.atan(0.0)) / Math.PI;
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return B_s * tmp;
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): tmp = 0 if B_m <= 3.55e-152: tmp = (180.0 * math.atan(0.0)) / math.pi else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return B_s * tmp
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) tmp = 0.0 if (B_m <= 3.55e-152) tmp = Float64(Float64(180.0 * atan(0.0)) / pi); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return Float64(B_s * tmp) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp_2 = code(B_s, A, B_m, C) tmp = 0.0; if (B_m <= 3.55e-152) tmp = (180.0 * atan(0.0)) / pi; else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = B_s * tmp; end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * If[LessEqual[B$95$m, 3.55e-152], N[(N[(180.0 * N[ArcTan[0.0], $MachinePrecision]), $MachinePrecision] / Pi), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \begin{array}{l}
\mathbf{if}\;B\_m \leq 3.55 \cdot 10^{-152}:\\
\;\;\;\;\frac{180 \cdot \tan^{-1} 0}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
\end{array}
if B < 3.55000000000000005e-152Initial program 54.3%
lift-sqrt.f64N/A
lift-+.f64N/A
lift--.f64N/A
lift-pow.f64N/A
sub-flipN/A
mul-1-negN/A
lift-pow.f64N/A
mul-1-negN/A
sub-flipN/A
unpow2N/A
sub-negate-revN/A
mul-1-negN/A
sub-negate-revN/A
mul-1-negN/A
unpow2N/A
lower-hypot.f64N/A
mul-1-negN/A
sub-negate-revN/A
lift--.f6478.1
Applied rewrites78.1%
Taylor expanded in C around inf
associate-*r/N/A
*-commutativeN/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
mul0-lftN/A
metadata-evalN/A
distribute-rgt1-inN/A
lower-/.f64N/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lft13.1
Applied rewrites13.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6413.1
lift-/.f64N/A
div013.1
Applied rewrites13.1%
if 3.55000000000000005e-152 < B Initial program 54.3%
Taylor expanded in B around inf
Applied rewrites40.4%
B\_m = (fabs.f64 B) B\_s = (copysign.f64 #s(literal 1 binary64) B) (FPCore (B_s A B_m C) :precision binary64 (* B_s (* 180.0 (/ (atan -1.0) PI))))
B\_m = fabs(B);
B\_s = copysign(1.0, B);
double code(double B_s, double A, double B_m, double C) {
return B_s * (180.0 * (atan(-1.0) / ((double) M_PI)));
}
B\_m = Math.abs(B);
B\_s = Math.copySign(1.0, B);
public static double code(double B_s, double A, double B_m, double C) {
return B_s * (180.0 * (Math.atan(-1.0) / Math.PI));
}
B\_m = math.fabs(B) B\_s = math.copysign(1.0, B) def code(B_s, A, B_m, C): return B_s * (180.0 * (math.atan(-1.0) / math.pi))
B\_m = abs(B) B\_s = copysign(1.0, B) function code(B_s, A, B_m, C) return Float64(B_s * Float64(180.0 * Float64(atan(-1.0) / pi))) end
B\_m = abs(B); B\_s = sign(B) * abs(1.0); function tmp = code(B_s, A, B_m, C) tmp = B_s * (180.0 * (atan(-1.0) / pi)); end
B\_m = N[Abs[B], $MachinePrecision]
B\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[B$95$s_, A_, B$95$m_, C_] := N[(B$95$s * N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B\_m = \left|B\right|
\\
B\_s = \mathsf{copysign}\left(1, B\right)
\\
B\_s \cdot \left(180 \cdot \frac{\tan^{-1} -1}{\pi}\right)
\end{array}
Initial program 54.3%
Taylor expanded in B around inf
Applied rewrites40.4%
herbie shell --seed 2025142
(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)))