
(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]
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}
Herbie found 9 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]
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}
(FPCore (A B C)
:precision binary64
(*
(copysign 1.0 B)
(if (<=
(*
180.0
(/
(atan
(*
(/ 1.0 (fabs B))
(-
(- C A)
(sqrt (+ (pow (- A C) 2.0) (pow (fabs B) 2.0))))))
PI))
-40.0)
(*
(/ (atan (/ (- (- C A) (hypot (- C A) (fabs B))) (fabs B))) PI)
180.0)
(*
(atan (fma (/ (fabs B) C) -0.5 (/ 0.0 (fabs B))))
(* (/ 1.0 PI) 180.0)))))double code(double A, double B, double C) {
double tmp;
if ((180.0 * (atan(((1.0 / fabs(B)) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(fabs(B), 2.0)))))) / ((double) M_PI))) <= -40.0) {
tmp = (atan((((C - A) - hypot((C - A), fabs(B))) / fabs(B))) / ((double) M_PI)) * 180.0;
} else {
tmp = atan(fma((fabs(B) / C), -0.5, (0.0 / fabs(B)))) * ((1.0 / ((double) M_PI)) * 180.0);
}
return copysign(1.0, B) * tmp;
}
function code(A, B, C) tmp = 0.0 if (Float64(180.0 * Float64(atan(Float64(Float64(1.0 / abs(B)) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (abs(B) ^ 2.0)))))) / pi)) <= -40.0) tmp = Float64(Float64(atan(Float64(Float64(Float64(C - A) - hypot(Float64(C - A), abs(B))) / abs(B))) / pi) * 180.0); else tmp = Float64(atan(fma(Float64(abs(B) / C), -0.5, Float64(0.0 / abs(B)))) * Float64(Float64(1.0 / pi) * 180.0)); end return Float64(copysign(1.0, B) * tmp) end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(180.0 * N[(N[ArcTan[N[(N[(1.0 / N[Abs[B], $MachinePrecision]), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Abs[B], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], -40.0], N[(N[(N[ArcTan[N[(N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(C - A), $MachinePrecision] ^ 2 + N[Abs[B], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / N[Abs[B], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision], N[(N[ArcTan[N[(N[(N[Abs[B], $MachinePrecision] / C), $MachinePrecision] * -0.5 + N[(0.0 / N[Abs[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(1.0 / Pi), $MachinePrecision] * 180.0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;180 \cdot \frac{\tan^{-1} \left(\frac{1}{\left|B\right|} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {\left(\left|B\right|\right)}^{2}}\right)\right)}{\pi} \leq -40:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{\left(C - A\right) - \mathsf{hypot}\left(C - A, \left|B\right|\right)}{\left|B\right|}\right)}{\pi} \cdot 180\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1} \left(\mathsf{fma}\left(\frac{\left|B\right|}{C}, -0.5, \frac{0}{\left|B\right|}\right)\right) \cdot \left(\frac{1}{\pi} \cdot 180\right)\\
\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 53.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6453.2%
Applied rewrites53.2%
Taylor expanded in A around 0
Applied rewrites51.7%
lift-sqrt.f64N/A
pow1/2N/A
lift-fma.f64N/A
pow2N/A
lift--.f64N/A
lift-*.f64N/A
pow2N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift--.f64N/A
pow2N/A
pow2N/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
Applied rewrites72.5%
Taylor expanded in C around 0
lower--.f6478.2%
Applied rewrites78.2%
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 53.2%
Taylor expanded in C around inf
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites25.6%
(FPCore (A B C) :precision binary64 (if (<= A -3.1e+149) (/ (* (atan (/ (* 0.5 (fma (/ C A) B B)) A)) 180.0) PI) (* (/ (atan (/ (- C (hypot (- C A) B)) B)) PI) 180.0)))
double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+149) {
tmp = (atan(((0.5 * fma((C / A), B, B)) / A)) * 180.0) / ((double) M_PI);
} else {
tmp = (atan(((C - hypot((C - A), B)) / B)) / ((double) M_PI)) * 180.0;
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (A <= -3.1e+149) tmp = Float64(Float64(atan(Float64(Float64(0.5 * fma(Float64(C / A), B, B)) / A)) * 180.0) / pi); else tmp = Float64(Float64(atan(Float64(Float64(C - hypot(Float64(C - A), B)) / B)) / pi) * 180.0); end return tmp end
code[A_, B_, C_] := If[LessEqual[A, -3.1e+149], N[(N[(N[ArcTan[N[(N[(0.5 * N[(N[(C / A), $MachinePrecision] * B + B), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - N[Sqrt[N[(C - A), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision] * 180.0), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;A \leq -3.1 \cdot 10^{+149}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{0.5 \cdot \mathsf{fma}\left(\frac{C}{A}, B, B\right)}{A}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \mathsf{hypot}\left(C - A, B\right)}{B}\right)}{\pi} \cdot 180\\
\end{array}
if A < -3.0999999999999999e149Initial program 53.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-/.f6448.9%
Applied rewrites48.9%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6432.8%
Applied rewrites32.8%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites33.0%
if -3.0999999999999999e149 < A Initial program 53.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6453.2%
Applied rewrites53.2%
Taylor expanded in A around 0
Applied rewrites51.7%
lift-sqrt.f64N/A
pow1/2N/A
lift-fma.f64N/A
pow2N/A
lift--.f64N/A
lift-*.f64N/A
pow2N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift--.f64N/A
pow2N/A
pow2N/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
Applied rewrites72.5%
(FPCore (A B C)
:precision binary64
(*
(copysign 1.0 B)
(if (<= C 2.5e+64)
(*
(*
(atan
(/ (* (/ (- C (+ A (fabs B))) (fabs B)) (fabs B)) (fabs B)))
180.0)
(/ 1.0 PI))
(* (/ 180.0 PI) (atan (/ (* -0.5 (fabs B)) C))))))double code(double A, double B, double C) {
double tmp;
if (C <= 2.5e+64) {
tmp = (atan(((((C - (A + fabs(B))) / fabs(B)) * fabs(B)) / fabs(B))) * 180.0) * (1.0 / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((-0.5 * fabs(B)) / C));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 2.5e+64) {
tmp = (Math.atan(((((C - (A + Math.abs(B))) / Math.abs(B)) * Math.abs(B)) / Math.abs(B))) * 180.0) * (1.0 / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(((-0.5 * Math.abs(B)) / C));
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if C <= 2.5e+64: tmp = (math.atan(((((C - (A + math.fabs(B))) / math.fabs(B)) * math.fabs(B)) / math.fabs(B))) * 180.0) * (1.0 / math.pi) else: tmp = (180.0 / math.pi) * math.atan(((-0.5 * math.fabs(B)) / C)) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (C <= 2.5e+64) tmp = Float64(Float64(atan(Float64(Float64(Float64(Float64(C - Float64(A + abs(B))) / abs(B)) * abs(B)) / abs(B))) * 180.0) * Float64(1.0 / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(-0.5 * abs(B)) / C))); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 2.5e+64) tmp = (atan(((((C - (A + abs(B))) / abs(B)) * abs(B)) / abs(B))) * 180.0) * (1.0 / pi); else tmp = (180.0 / pi) * atan(((-0.5 * abs(B)) / C)); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[C, 2.5e+64], N[(N[(N[ArcTan[N[(N[(N[(N[(C - N[(A + N[Abs[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Abs[B], $MachinePrecision]), $MachinePrecision] * N[Abs[B], $MachinePrecision]), $MachinePrecision] / N[Abs[B], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] * N[(1.0 / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(-0.5 * N[Abs[B], $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;C \leq 2.5 \cdot 10^{+64}:\\
\;\;\;\;\left(\tan^{-1} \left(\frac{\frac{C - \left(A + \left|B\right|\right)}{\left|B\right|} \cdot \left|B\right|}{\left|B\right|}\right) \cdot 180\right) \cdot \frac{1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{-0.5 \cdot \left|B\right|}{C}\right)\\
\end{array}
if C < 2.5e64Initial program 53.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-/.f6448.9%
Applied rewrites48.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
mult-flipN/A
lower-*.f64N/A
Applied rewrites50.2%
if 2.5e64 < C Initial program 53.2%
Taylor expanded in C around inf
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
lift-fma.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
mult-flipN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-/.f64N/A
mul-1-negN/A
lift-/.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
lift-+.f64N/A
lift-*.f64N/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lftN/A
metadata-eval25.6%
Applied rewrites25.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
(FPCore (A B C) :precision binary64 (* (copysign 1.0 B) (if (<= C 8.5e+63) (* 180.0 (/ (atan (- (/ C (fabs B)) (+ 1.0 (/ A (fabs B))))) PI)) (* (/ 180.0 PI) (atan (/ (* -0.5 (fabs B)) C))))))
double code(double A, double B, double C) {
double tmp;
if (C <= 8.5e+63) {
tmp = 180.0 * (atan(((C / fabs(B)) - (1.0 + (A / fabs(B))))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((-0.5 * fabs(B)) / C));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= 8.5e+63) {
tmp = 180.0 * (Math.atan(((C / Math.abs(B)) - (1.0 + (A / Math.abs(B))))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(((-0.5 * Math.abs(B)) / C));
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if C <= 8.5e+63: tmp = 180.0 * (math.atan(((C / math.fabs(B)) - (1.0 + (A / math.fabs(B))))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(((-0.5 * math.fabs(B)) / C)) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (C <= 8.5e+63) tmp = Float64(180.0 * Float64(atan(Float64(Float64(C / abs(B)) - Float64(1.0 + Float64(A / abs(B))))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(-0.5 * abs(B)) / C))); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= 8.5e+63) tmp = 180.0 * (atan(((C / abs(B)) - (1.0 + (A / abs(B))))) / pi); else tmp = (180.0 / pi) * atan(((-0.5 * abs(B)) / C)); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[C, 8.5e+63], N[(180.0 * N[(N[ArcTan[N[(N[(C / N[Abs[B], $MachinePrecision]), $MachinePrecision] - N[(1.0 + N[(A / N[Abs[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(-0.5 * N[Abs[B], $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;C \leq 8.5 \cdot 10^{+63}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(\frac{C}{\left|B\right|} - \left(1 + \frac{A}{\left|B\right|}\right)\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{-0.5 \cdot \left|B\right|}{C}\right)\\
\end{array}
if C < 8.5000000000000004e63Initial program 53.2%
Taylor expanded in B around inf
lower--.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-/.f6448.9%
Applied rewrites48.9%
if 8.5000000000000004e63 < C Initial program 53.2%
Taylor expanded in C around inf
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
lift-fma.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
mult-flipN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-/.f64N/A
mul-1-negN/A
lift-/.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
lift-+.f64N/A
lift-*.f64N/A
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lftN/A
metadata-eval25.6%
Applied rewrites25.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites25.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
(FPCore (A B C)
:precision binary64
(*
(copysign 1.0 B)
(if (<= A -3.1e+149)
(/ (* (atan (* (/ (fabs B) A) 0.5)) 180.0) PI)
(if (<= A 2.6e+64)
(* 180.0 (/ (atan -1.0) PI))
(* 180.0 (/ (atan (* -2.0 (/ A (fabs B)))) PI))))))double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+149) {
tmp = (atan(((fabs(B) / A) * 0.5)) * 180.0) / ((double) M_PI);
} else if (A <= 2.6e+64) {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-2.0 * (A / fabs(B)))) / ((double) M_PI));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+149) {
tmp = (Math.atan(((Math.abs(B) / A) * 0.5)) * 180.0) / Math.PI;
} else if (A <= 2.6e+64) {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-2.0 * (A / Math.abs(B)))) / Math.PI);
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.1e+149: tmp = (math.atan(((math.fabs(B) / A) * 0.5)) * 180.0) / math.pi elif A <= 2.6e+64: tmp = 180.0 * (math.atan(-1.0) / math.pi) else: tmp = 180.0 * (math.atan((-2.0 * (A / math.fabs(B)))) / math.pi) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.1e+149) tmp = Float64(Float64(atan(Float64(Float64(abs(B) / A) * 0.5)) * 180.0) / pi); elseif (A <= 2.6e+64) tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / abs(B)))) / pi)); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.1e+149) tmp = (atan(((abs(B) / A) * 0.5)) * 180.0) / pi; elseif (A <= 2.6e+64) tmp = 180.0 * (atan(-1.0) / pi); else tmp = 180.0 * (atan((-2.0 * (A / abs(B)))) / pi); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[A, -3.1e+149], N[(N[(N[ArcTan[N[(N[(N[Abs[B], $MachinePrecision] / A), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 2.6e+64], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / N[Abs[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.1 \cdot 10^{+149}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{\left|B\right|}{A} \cdot 0.5\right) \cdot 180}{\pi}\\
\mathbf{elif}\;A \leq 2.6 \cdot 10^{+64}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{\left|B\right|}\right)}{\pi}\\
\end{array}
if A < -3.0999999999999999e149Initial program 53.2%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6426.1%
Applied rewrites26.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites26.1%
if -3.0999999999999999e149 < A < 2.6e64Initial program 53.2%
Taylor expanded in B around inf
Applied rewrites21.4%
if 2.6e64 < A Initial program 53.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-/.f6448.9%
Applied rewrites48.9%
Taylor expanded in A around inf
lower-*.f64N/A
lower-/.f6423.1%
Applied rewrites23.1%
(FPCore (A B C)
:precision binary64
(*
(copysign 1.0 B)
(if (<= A -3.1e+149)
(* 180.0 (/ (atan (* 0.5 (/ (fabs B) A))) PI))
(if (<= A 2.6e+64)
(* 180.0 (/ (atan -1.0) PI))
(* 180.0 (/ (atan (* -2.0 (/ A (fabs B)))) PI))))))double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+149) {
tmp = 180.0 * (atan((0.5 * (fabs(B) / A))) / ((double) M_PI));
} else if (A <= 2.6e+64) {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-2.0 * (A / fabs(B)))) / ((double) M_PI));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -3.1e+149) {
tmp = 180.0 * (Math.atan((0.5 * (Math.abs(B) / A))) / Math.PI);
} else if (A <= 2.6e+64) {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-2.0 * (A / Math.abs(B)))) / Math.PI);
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if A <= -3.1e+149: tmp = 180.0 * (math.atan((0.5 * (math.fabs(B) / A))) / math.pi) elif A <= 2.6e+64: tmp = 180.0 * (math.atan(-1.0) / math.pi) else: tmp = 180.0 * (math.atan((-2.0 * (A / math.fabs(B)))) / math.pi) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (A <= -3.1e+149) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(abs(B) / A))) / pi)); elseif (A <= 2.6e+64) tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / abs(B)))) / pi)); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -3.1e+149) tmp = 180.0 * (atan((0.5 * (abs(B) / A))) / pi); elseif (A <= 2.6e+64) tmp = 180.0 * (atan(-1.0) / pi); else tmp = 180.0 * (atan((-2.0 * (A / abs(B)))) / pi); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[A, -3.1e+149], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(N[Abs[B], $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 2.6e+64], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / N[Abs[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;A \leq -3.1 \cdot 10^{+149}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{\left|B\right|}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 2.6 \cdot 10^{+64}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{\left|B\right|}\right)}{\pi}\\
\end{array}
if A < -3.0999999999999999e149Initial program 53.2%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6426.1%
Applied rewrites26.1%
if -3.0999999999999999e149 < A < 2.6e64Initial program 53.2%
Taylor expanded in B around inf
Applied rewrites21.4%
if 2.6e64 < A Initial program 53.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-/.f6448.9%
Applied rewrites48.9%
Taylor expanded in A around inf
lower-*.f64N/A
lower-/.f6423.1%
Applied rewrites23.1%
(FPCore (A B C)
:precision binary64
(*
(copysign 1.0 B)
(if (<= C -4.3e+191)
(* (/ 180.0 PI) (atan (/ (+ C C) (fabs B))))
(if (<= C 6.5e+64)
(* 180.0 (/ (atan -1.0) PI))
(* 180.0 (/ (atan (* -0.5 (/ (fabs B) C))) PI))))))double code(double A, double B, double C) {
double tmp;
if (C <= -4.3e+191) {
tmp = (180.0 / ((double) M_PI)) * atan(((C + C) / fabs(B)));
} else if (C <= 6.5e+64) {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
} else {
tmp = 180.0 * (atan((-0.5 * (fabs(B) / C))) / ((double) M_PI));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -4.3e+191) {
tmp = (180.0 / Math.PI) * Math.atan(((C + C) / Math.abs(B)));
} else if (C <= 6.5e+64) {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
} else {
tmp = 180.0 * (Math.atan((-0.5 * (Math.abs(B) / C))) / Math.PI);
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if C <= -4.3e+191: tmp = (180.0 / math.pi) * math.atan(((C + C) / math.fabs(B))) elif C <= 6.5e+64: tmp = 180.0 * (math.atan(-1.0) / math.pi) else: tmp = 180.0 * (math.atan((-0.5 * (math.fabs(B) / C))) / math.pi) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (C <= -4.3e+191) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C + C) / abs(B)))); elseif (C <= 6.5e+64) tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); else tmp = Float64(180.0 * Float64(atan(Float64(-0.5 * Float64(abs(B) / C))) / pi)); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -4.3e+191) tmp = (180.0 / pi) * atan(((C + C) / abs(B))); elseif (C <= 6.5e+64) tmp = 180.0 * (atan(-1.0) / pi); else tmp = 180.0 * (atan((-0.5 * (abs(B) / C))) / pi); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[C, -4.3e+191], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C + C), $MachinePrecision] / N[Abs[B], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6.5e+64], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-0.5 * N[(N[Abs[B], $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;C \leq -4.3 \cdot 10^{+191}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C + C}{\left|B\right|}\right)\\
\mathbf{elif}\;C \leq 6.5 \cdot 10^{+64}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-0.5 \cdot \frac{\left|B\right|}{C}\right)}{\pi}\\
\end{array}
if C < -4.2999999999999998e191Initial program 53.2%
Taylor expanded in C around -inf
lower-*.f64N/A
lower-/.f6422.6%
Applied rewrites22.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites22.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6422.6%
Applied rewrites22.6%
if -4.2999999999999998e191 < C < 6.5000000000000001e64Initial program 53.2%
Taylor expanded in B around inf
Applied rewrites21.4%
if 6.5000000000000001e64 < C Initial program 53.2%
Taylor expanded in C around inf
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
Taylor expanded in A around 0
lower-*.f64N/A
lower-/.f6425.6%
Applied rewrites25.6%
(FPCore (A B C) :precision binary64 (* (copysign 1.0 B) (if (<= C -4.3e+191) (* (/ 180.0 PI) (atan (/ (+ C C) (fabs B)))) (* 180.0 (/ (atan -1.0) PI)))))
double code(double A, double B, double C) {
double tmp;
if (C <= -4.3e+191) {
tmp = (180.0 / ((double) M_PI)) * atan(((C + C) / fabs(B)));
} else {
tmp = 180.0 * (atan(-1.0) / ((double) M_PI));
}
return copysign(1.0, B) * tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (C <= -4.3e+191) {
tmp = (180.0 / Math.PI) * Math.atan(((C + C) / Math.abs(B)));
} else {
tmp = 180.0 * (Math.atan(-1.0) / Math.PI);
}
return Math.copySign(1.0, B) * tmp;
}
def code(A, B, C): tmp = 0 if C <= -4.3e+191: tmp = (180.0 / math.pi) * math.atan(((C + C) / math.fabs(B))) else: tmp = 180.0 * (math.atan(-1.0) / math.pi) return math.copysign(1.0, B) * tmp
function code(A, B, C) tmp = 0.0 if (C <= -4.3e+191) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C + C) / abs(B)))); else tmp = Float64(180.0 * Float64(atan(-1.0) / pi)); end return Float64(copysign(1.0, B) * tmp) end
function tmp_2 = code(A, B, C) tmp = 0.0; if (C <= -4.3e+191) tmp = (180.0 / pi) * atan(((C + C) / abs(B))); else tmp = 180.0 * (atan(-1.0) / pi); end tmp_2 = (sign(B) * abs(1.0)) * tmp; end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[C, -4.3e+191], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C + C), $MachinePrecision] / N[Abs[B], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \begin{array}{l}
\mathbf{if}\;C \leq -4.3 \cdot 10^{+191}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C + C}{\left|B\right|}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} -1}{\pi}\\
\end{array}
if C < -4.2999999999999998e191Initial program 53.2%
Taylor expanded in C around -inf
lower-*.f64N/A
lower-/.f6422.6%
Applied rewrites22.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites22.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6422.6%
Applied rewrites22.6%
if -4.2999999999999998e191 < C Initial program 53.2%
Taylor expanded in B around inf
Applied rewrites21.4%
(FPCore (A B C) :precision binary64 (* (copysign 1.0 B) (* 180.0 (/ (atan -1.0) PI))))
double code(double A, double B, double C) {
return copysign(1.0, B) * (180.0 * (atan(-1.0) / ((double) M_PI)));
}
public static double code(double A, double B, double C) {
return Math.copySign(1.0, B) * (180.0 * (Math.atan(-1.0) / Math.PI));
}
def code(A, B, C): return math.copysign(1.0, B) * (180.0 * (math.atan(-1.0) / math.pi))
function code(A, B, C) return Float64(copysign(1.0, B) * Float64(180.0 * Float64(atan(-1.0) / pi))) end
function tmp = code(A, B, C) tmp = (sign(B) * abs(1.0)) * (180.0 * (atan(-1.0) / pi)); end
code[A_, B_, C_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[B]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * N[(180.0 * N[(N[ArcTan[-1.0], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\mathsf{copysign}\left(1, B\right) \cdot \left(180 \cdot \frac{\tan^{-1} -1}{\pi}\right)
Initial program 53.2%
Taylor expanded in B around inf
Applied rewrites21.4%
herbie shell --seed 2025212
(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)))