
(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 13 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)) 180.0) PI)))
(if (<= t_0 -10.0)
t_1
(if (<= t_0 0.0) (* 180.0 (/ (atan (* 0.5 (/ B 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)) * 180.0) / ((double) M_PI);
double tmp;
if (t_0 <= -10.0) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = 180.0 * (atan((0.5 * (B / 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)) * 180.0) / Math.PI;
double tmp;
if (t_0 <= -10.0) {
tmp = t_1;
} else if (t_0 <= 0.0) {
tmp = 180.0 * (Math.atan((0.5 * (B / 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)) * 180.0) / math.pi tmp = 0 if t_0 <= -10.0: tmp = t_1 elif t_0 <= 0.0: tmp = 180.0 * (math.atan((0.5 * (B / 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)) * 180.0) / pi) tmp = 0.0 if (t_0 <= -10.0) tmp = t_1; elseif (t_0 <= 0.0) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / 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)) * 180.0) / pi; tmp = 0.0; if (t_0 <= -10.0) tmp = t_1; elseif (t_0 <= 0.0) tmp = 180.0 * (atan((0.5 * (B / 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] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]}, If[LessEqual[t$95$0, -10.0], t$95$1, If[LessEqual[t$95$0, 0.0], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $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) \cdot 180}{\pi}\\
\mathbf{if}\;t\_0 \leq -10:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{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))) < -10 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 58.7%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites86.7%
if -10 < (*.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 18.2%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6418.2
lift-pow.f64N/A
unpow2N/A
lower-*.f6418.2
Applied rewrites18.2%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6416.8
Applied rewrites16.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f648.6
Applied rewrites8.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6449.8
Applied rewrites49.8%
(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)
(* (/ 180.0 PI) (atan (/ (- C (+ B A)) B)))
(if (<= t_0 0.0)
(* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
(* (/ 180.0 PI) (atan (/ (- C (+ (* -1.0 B) A)) B)))))))
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 = (180.0 / ((double) M_PI)) * atan(((C - (B + A)) / B));
} else if (t_0 <= 0.0) {
tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - ((-1.0 * B) + A)) / B));
}
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 = (180.0 / Math.PI) * Math.atan(((C - (B + A)) / B));
} else if (t_0 <= 0.0) {
tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - ((-1.0 * B) + A)) / B));
}
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 = (180.0 / math.pi) * math.atan(((C - (B + A)) / B)) elif t_0 <= 0.0: tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(((C - ((-1.0 * B) + A)) / B)) 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(180.0 / pi) * atan(Float64(Float64(C - Float64(B + A)) / B))); elseif (t_0 <= 0.0) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(Float64(-1.0 * B) + A)) / B))); 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 = (180.0 / pi) * atan(((C - (B + A)) / B)); elseif (t_0 <= 0.0) tmp = 180.0 * (atan((0.5 * (B / A))) / pi); else tmp = (180.0 / pi) * atan(((C - ((-1.0 * B) + A)) / B)); 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[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(N[(-1.0 * B), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $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{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(-1 \cdot B + A\right)}{B}\right)\\
\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.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites87.4%
Applied rewrites82.8%
Applied rewrites82.8%
Taylor expanded in B around inf
Applied rewrites76.8%
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.0Initial program 18.2%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6418.2
lift-pow.f64N/A
unpow2N/A
lower-*.f6418.2
Applied rewrites18.2%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6416.8
Applied rewrites16.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f648.6
Applied rewrites8.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6449.8
Applied rewrites49.8%
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 57.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites86.1%
Applied rewrites81.1%
Applied rewrites81.1%
Taylor expanded in B around -inf
lower-*.f6474.9
Applied rewrites74.9%
(FPCore (A B C)
:precision binary64
(let* ((t_0
(* (/ 1.0 B) (- (- C A) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
(if (<= t_0 -0.5)
(* (/ 180.0 PI) (atan (/ (- C (+ B A)) B)))
(if (<= t_0 0.0)
(* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
(/ (* (atan (/ (- C (* -1.0 B)) B)) 180.0) PI)))))
double code(double A, double B, double C) {
double t_0 = (1.0 / B) * ((C - A) - sqrt((pow((A - C), 2.0) + pow(B, 2.0))));
double tmp;
if (t_0 <= -0.5) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - (B + A)) / B));
} else if (t_0 <= 0.0) {
tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
} else {
tmp = (atan(((C - (-1.0 * B)) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double t_0 = (1.0 / B) * ((C - A) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0))));
double tmp;
if (t_0 <= -0.5) {
tmp = (180.0 / Math.PI) * Math.atan(((C - (B + A)) / B));
} else if (t_0 <= 0.0) {
tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
} else {
tmp = (Math.atan(((C - (-1.0 * B)) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): t_0 = (1.0 / B) * ((C - A) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))) tmp = 0 if t_0 <= -0.5: tmp = (180.0 / math.pi) * math.atan(((C - (B + A)) / B)) elif t_0 <= 0.0: tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi) else: tmp = (math.atan(((C - (-1.0 * B)) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) t_0 = Float64(Float64(1.0 / B) * Float64(Float64(C - A) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))) tmp = 0.0 if (t_0 <= -0.5) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(B + A)) / B))); elseif (t_0 <= 0.0) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi)); else tmp = Float64(Float64(atan(Float64(Float64(C - Float64(-1.0 * B)) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) t_0 = (1.0 / B) * ((C - A) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))); tmp = 0.0; if (t_0 <= -0.5) tmp = (180.0 / pi) * atan(((C - (B + A)) / B)); elseif (t_0 <= 0.0) tmp = 180.0 * (atan((0.5 * (B / A))) / pi); else tmp = (atan(((C - (-1.0 * B)) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := Block[{t$95$0 = N[(N[(1.0 / B), $MachinePrecision] * N[(N[(C - A), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.5], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], 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 - N[(-1.0 * B), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{B} \cdot \left(\left(C - A\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)\\
\mathbf{if}\;t\_0 \leq -0.5:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - -1 \cdot B}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) < -0.5Initial program 60.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites87.4%
Applied rewrites82.8%
Applied rewrites82.8%
Taylor expanded in B around inf
Applied rewrites76.8%
if -0.5 < (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) < -0.0Initial program 18.2%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6418.2
lift-pow.f64N/A
unpow2N/A
lower-*.f6418.2
Applied rewrites18.2%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6416.8
Applied rewrites16.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f648.6
Applied rewrites8.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6449.8
Applied rewrites49.8%
if -0.0 < (*.f64 (/.f64 #s(literal 1 binary64) B) (-.f64 (-.f64 C A) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))) Initial program 57.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites86.1%
Applied rewrites81.1%
lift-+.f64N/A
Applied rewrites0.2%
Taylor expanded in B around -inf
lower-*.f6463.1
Applied rewrites63.1%
(FPCore (A B C) :precision binary64 (if (<= A -4.6e+195) (/ (* (atan (* 0.5 (/ B A))) 180.0) PI) (/ (* (atan (/ (- C (+ (hypot B (- A C)) A)) B)) 180.0) PI)))
double code(double A, double B, double C) {
double tmp;
if (A <= -4.6e+195) {
tmp = (atan((0.5 * (B / A))) * 180.0) / ((double) M_PI);
} else {
tmp = (atan(((C - (hypot(B, (A - C)) + A)) / B)) * 180.0) / ((double) M_PI);
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -4.6e+195) {
tmp = (Math.atan((0.5 * (B / A))) * 180.0) / Math.PI;
} else {
tmp = (Math.atan(((C - (Math.hypot(B, (A - C)) + A)) / B)) * 180.0) / Math.PI;
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -4.6e+195: tmp = (math.atan((0.5 * (B / A))) * 180.0) / math.pi else: tmp = (math.atan(((C - (math.hypot(B, (A - C)) + A)) / B)) * 180.0) / math.pi return tmp
function code(A, B, C) tmp = 0.0 if (A <= -4.6e+195) tmp = Float64(Float64(atan(Float64(0.5 * Float64(B / A))) * 180.0) / pi); else tmp = Float64(Float64(atan(Float64(Float64(C - Float64(hypot(B, Float64(A - C)) + A)) / B)) * 180.0) / pi); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -4.6e+195) tmp = (atan((0.5 * (B / A))) * 180.0) / pi; else tmp = (atan(((C - (hypot(B, (A - C)) + A)) / B)) * 180.0) / pi; end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -4.6e+195], N[(N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(N[ArcTan[N[(N[(C - N[(N[Sqrt[B ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -4.6 \cdot 10^{+195}:\\
\;\;\;\;\frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} \left(\frac{C - \left(\mathsf{hypot}\left(B, A - C\right) + A\right)}{B}\right) \cdot 180}{\pi}\\
\end{array}
\end{array}
if A < -4.6000000000000002e195Initial program 9.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites54.8%
Applied rewrites18.5%
lift-/.f64N/A
lift--.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate--r+N/A
lift--.f64N/A
sub-divN/A
frac-subN/A
lift-*.f64N/A
div-subN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites4.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6485.6
Applied rewrites85.6%
if -4.6000000000000002e195 < A Initial program 57.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites80.2%
Applied rewrites78.3%
(FPCore (A B C) :precision binary64 (if (<= A -4.6e+195) (/ (* (atan (* 0.5 (/ B A))) 180.0) PI) (* (/ 180.0 PI) (atan (/ (- C (+ (hypot (- A C) B) A)) B)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -4.6e+195) {
tmp = (atan((0.5 * (B / A))) * 180.0) / ((double) M_PI);
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - (hypot((A - C), B) + A)) / B));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -4.6e+195) {
tmp = (Math.atan((0.5 * (B / A))) * 180.0) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - (Math.hypot((A - C), B) + A)) / B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -4.6e+195: tmp = (math.atan((0.5 * (B / A))) * 180.0) / math.pi else: tmp = (180.0 / math.pi) * math.atan(((C - (math.hypot((A - C), B) + A)) / B)) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -4.6e+195) tmp = Float64(Float64(atan(Float64(0.5 * Float64(B / A))) * 180.0) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(hypot(Float64(A - C), B) + A)) / B))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -4.6e+195) tmp = (atan((0.5 * (B / A))) * 180.0) / pi; else tmp = (180.0 / pi) * atan(((C - (hypot((A - C), B) + A)) / B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -4.6e+195], N[(N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B ^ 2], $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -4.6 \cdot 10^{+195}:\\
\;\;\;\;\frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(\mathsf{hypot}\left(A - C, B\right) + A\right)}{B}\right)\\
\end{array}
\end{array}
if A < -4.6000000000000002e195Initial program 9.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites54.8%
Applied rewrites18.5%
lift-/.f64N/A
lift--.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate--r+N/A
lift--.f64N/A
sub-divN/A
frac-subN/A
lift-*.f64N/A
div-subN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites4.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6485.6
Applied rewrites85.6%
if -4.6000000000000002e195 < A Initial program 57.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites80.2%
Applied rewrites78.3%
Applied rewrites78.4%
(FPCore (A B C) :precision binary64 (if (<= C 7e+91) (* (/ 180.0 PI) (atan (/ (- C (+ (hypot A B) A)) B))) (* (/ 180.0 PI) (atan (fma -1.0 (/ (+ A (* -1.0 A)) B) (* -0.5 (/ B C)))))))
double code(double A, double B, double C) {
double tmp;
if (C <= 7e+91) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - (hypot(A, B) + A)) / B));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(fma(-1.0, ((A + (-1.0 * A)) / B), (-0.5 * (B / C))));
}
return tmp;
}
function code(A, B, C) tmp = 0.0 if (C <= 7e+91) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(hypot(A, B) + A)) / B))); else tmp = Float64(Float64(180.0 / pi) * atan(fma(-1.0, Float64(Float64(A + Float64(-1.0 * A)) / B), Float64(-0.5 * Float64(B / C))))); end return tmp end
code[A_, B_, C_] := If[LessEqual[C, 7e+91], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(N[Sqrt[A ^ 2 + B ^ 2], $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(-1.0 * N[(N[(A + N[(-1.0 * A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision] + N[(-0.5 * N[(B / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;C \leq 7 \cdot 10^{+91}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(\mathsf{hypot}\left(A, B\right) + A\right)}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\mathsf{fma}\left(-1, \frac{A + -1 \cdot A}{B}, -0.5 \cdot \frac{B}{C}\right)\right)\\
\end{array}
\end{array}
if C < 7.00000000000000001e91Initial program 60.8%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites83.0%
Applied rewrites77.5%
Applied rewrites77.5%
Taylor expanded in A around inf
Applied rewrites76.4%
if 7.00000000000000001e91 < C Initial program 18.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites53.5%
Applied rewrites50.4%
Applied rewrites50.5%
Taylor expanded in C around inf
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6476.0
Applied rewrites76.0%
(FPCore (A B C)
:precision binary64
(if (<= A -9.5e-77)
(/ (* (atan (* 0.5 (/ B A))) 180.0) PI)
(if (<= A 1.02e+43)
(* (/ 180.0 PI) (atan (/ (- C B) B)))
(* 180.0 (/ (atan (* -2.0 (/ A B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -9.5e-77) {
tmp = (atan((0.5 * (B / A))) * 180.0) / ((double) M_PI);
} else if (A <= 1.02e+43) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
} else {
tmp = 180.0 * (atan((-2.0 * (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -9.5e-77) {
tmp = (Math.atan((0.5 * (B / A))) * 180.0) / Math.PI;
} else if (A <= 1.02e+43) {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
} else {
tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -9.5e-77: tmp = (math.atan((0.5 * (B / A))) * 180.0) / math.pi elif A <= 1.02e+43: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) else: tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -9.5e-77) tmp = Float64(Float64(atan(Float64(0.5 * Float64(B / A))) * 180.0) / pi); elseif (A <= 1.02e+43) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -9.5e-77) tmp = (atan((0.5 * (B / A))) * 180.0) / pi; elseif (A <= 1.02e+43) tmp = (180.0 / pi) * atan(((C - B) / B)); else tmp = 180.0 * (atan((-2.0 * (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -9.5e-77], N[(N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[A, 1.02e+43], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -9.5 \cdot 10^{-77}:\\
\;\;\;\;\frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right) \cdot 180}{\pi}\\
\mathbf{elif}\;A \leq 1.02 \cdot 10^{+43}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -9.5000000000000005e-77Initial program 29.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites60.7%
Applied rewrites45.1%
lift-/.f64N/A
lift--.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate--r+N/A
lift--.f64N/A
sub-divN/A
frac-subN/A
lift-*.f64N/A
div-subN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites19.9%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6458.1
Applied rewrites58.1%
if -9.5000000000000005e-77 < A < 1.02e43Initial program 59.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites82.1%
Applied rewrites82.1%
Applied rewrites82.1%
Taylor expanded in B around inf
Applied rewrites49.0%
if 1.02e43 < A Initial program 77.3%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6477.3
lift-pow.f64N/A
unpow2N/A
lower-*.f6477.3
Applied rewrites77.3%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6476.7
Applied rewrites76.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f6421.8
Applied rewrites21.8%
Taylor expanded in A around inf
lower-*.f64N/A
lower-/.f6471.3
Applied rewrites71.3%
(FPCore (A B C)
:precision binary64
(if (<= A -9.5e-77)
(* 180.0 (/ (atan (* 0.5 (/ B A))) PI))
(if (<= A 1.02e+43)
(* (/ 180.0 PI) (atan (/ (- C B) B)))
(* 180.0 (/ (atan (* -2.0 (/ A B))) PI)))))
double code(double A, double B, double C) {
double tmp;
if (A <= -9.5e-77) {
tmp = 180.0 * (atan((0.5 * (B / A))) / ((double) M_PI));
} else if (A <= 1.02e+43) {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
} else {
tmp = 180.0 * (atan((-2.0 * (A / B))) / ((double) M_PI));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (A <= -9.5e-77) {
tmp = 180.0 * (Math.atan((0.5 * (B / A))) / Math.PI);
} else if (A <= 1.02e+43) {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
} else {
tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
}
return tmp;
}
def code(A, B, C): tmp = 0 if A <= -9.5e-77: tmp = 180.0 * (math.atan((0.5 * (B / A))) / math.pi) elif A <= 1.02e+43: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) else: tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi) return tmp
function code(A, B, C) tmp = 0.0 if (A <= -9.5e-77) tmp = Float64(180.0 * Float64(atan(Float64(0.5 * Float64(B / A))) / pi)); elseif (A <= 1.02e+43) tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); else tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / pi)); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (A <= -9.5e-77) tmp = 180.0 * (atan((0.5 * (B / A))) / pi); elseif (A <= 1.02e+43) tmp = (180.0 / pi) * atan(((C - B) / B)); else tmp = 180.0 * (atan((-2.0 * (A / B))) / pi); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[A, -9.5e-77], N[(180.0 * N[(N[ArcTan[N[(0.5 * N[(B / A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.02e+43], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;A \leq -9.5 \cdot 10^{-77}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(0.5 \cdot \frac{B}{A}\right)}{\pi}\\
\mathbf{elif}\;A \leq 1.02 \cdot 10^{+43}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\mathbf{else}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\
\end{array}
\end{array}
if A < -9.5000000000000005e-77Initial program 29.6%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6429.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6429.6
Applied rewrites29.6%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6426.6
Applied rewrites26.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f6413.6
Applied rewrites13.6%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-/.f6458.1
Applied rewrites58.1%
if -9.5000000000000005e-77 < A < 1.02e43Initial program 59.1%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites82.1%
Applied rewrites82.1%
Applied rewrites82.1%
Taylor expanded in B around inf
Applied rewrites49.0%
if 1.02e43 < A Initial program 77.3%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6477.3
lift-pow.f64N/A
unpow2N/A
lower-*.f6477.3
Applied rewrites77.3%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6476.7
Applied rewrites76.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f6421.8
Applied rewrites21.8%
Taylor expanded in A around inf
lower-*.f64N/A
lower-/.f6471.3
Applied rewrites71.3%
(FPCore (A B C)
:precision binary64
(if (<= B -2.3e-11)
(/ (* (atan 1.0) 180.0) PI)
(if (<= B 5e-257)
(* 180.0 (/ (atan (* -2.0 (/ A B))) PI))
(* (/ 180.0 PI) (atan (/ (- C B) B))))))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.3e-11) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else if (B <= 5e-257) {
tmp = 180.0 * (atan((-2.0 * (A / B))) / ((double) M_PI));
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -2.3e-11) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else if (B <= 5e-257) {
tmp = 180.0 * (Math.atan((-2.0 * (A / B))) / Math.PI);
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -2.3e-11: tmp = (math.atan(1.0) * 180.0) / math.pi elif B <= 5e-257: tmp = 180.0 * (math.atan((-2.0 * (A / B))) / math.pi) else: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -2.3e-11) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); elseif (B <= 5e-257) tmp = Float64(180.0 * Float64(atan(Float64(-2.0 * Float64(A / B))) / pi)); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -2.3e-11) tmp = (atan(1.0) * 180.0) / pi; elseif (B <= 5e-257) tmp = 180.0 * (atan((-2.0 * (A / B))) / pi); else tmp = (180.0 / pi) * atan(((C - B) / B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -2.3e-11], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], If[LessEqual[B, 5e-257], N[(180.0 * N[(N[ArcTan[N[(-2.0 * N[(A / B), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -2.3 \cdot 10^{-11}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{elif}\;B \leq 5 \cdot 10^{-257}:\\
\;\;\;\;180 \cdot \frac{\tan^{-1} \left(-2 \cdot \frac{A}{B}\right)}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\end{array}
\end{array}
if B < -2.30000000000000014e-11Initial program 46.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.9%
Applied rewrites77.9%
lift-+.f64N/A
Applied rewrites0.0%
Taylor expanded in B around -inf
Applied rewrites59.6%
if -2.30000000000000014e-11 < B < 4.99999999999999989e-257Initial program 59.4%
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f6459.4
lift-pow.f64N/A
unpow2N/A
lower-*.f6459.4
Applied rewrites59.4%
lift--.f64N/A
flip--N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f6457.2
Applied rewrites57.2%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-+.f64N/A
flip-+N/A
lift--.f64N/A
frac-timesN/A
lower-/.f64N/A
lower-*.f64N/A
difference-of-squaresN/A
lift-+.f64N/A
lift--.f64N/A
lower-*.f64N/A
lower-*.f6429.7
Applied rewrites29.7%
Taylor expanded in A around inf
lower-*.f64N/A
lower-/.f6431.7
Applied rewrites31.7%
if 4.99999999999999989e-257 < B Initial program 53.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.8%
Applied rewrites74.1%
Applied rewrites74.1%
Taylor expanded in B around inf
Applied rewrites57.7%
(FPCore (A B C) :precision binary64 (if (<= B -5e-11) (/ (* (atan 1.0) 180.0) PI) (* (/ 180.0 PI) (atan (/ (- C (+ B A)) B)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -5e-11) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - (B + A)) / B));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -5e-11) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - (B + A)) / B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -5e-11: tmp = (math.atan(1.0) * 180.0) / math.pi else: tmp = (180.0 / math.pi) * math.atan(((C - (B + A)) / B)) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -5e-11) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - Float64(B + A)) / B))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -5e-11) tmp = (atan(1.0) * 180.0) / pi; else tmp = (180.0 / pi) * atan(((C - (B + A)) / B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -5e-11], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - N[(B + A), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -5 \cdot 10^{-11}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - \left(B + A\right)}{B}\right)\\
\end{array}
\end{array}
if B < -5.00000000000000018e-11Initial program 46.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.9%
Applied rewrites77.9%
lift-+.f64N/A
Applied rewrites0.0%
Taylor expanded in B around -inf
Applied rewrites59.6%
if -5.00000000000000018e-11 < B Initial program 55.7%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.7%
Applied rewrites70.9%
Applied rewrites70.9%
Taylor expanded in B around inf
Applied rewrites60.5%
(FPCore (A B C) :precision binary64 (if (<= B -3.4e-127) (/ (* (atan 1.0) 180.0) PI) (* (/ 180.0 PI) (atan (/ (- C B) B)))))
double code(double A, double B, double C) {
double tmp;
if (B <= -3.4e-127) {
tmp = (atan(1.0) * 180.0) / ((double) M_PI);
} else {
tmp = (180.0 / ((double) M_PI)) * atan(((C - B) / B));
}
return tmp;
}
public static double code(double A, double B, double C) {
double tmp;
if (B <= -3.4e-127) {
tmp = (Math.atan(1.0) * 180.0) / Math.PI;
} else {
tmp = (180.0 / Math.PI) * Math.atan(((C - B) / B));
}
return tmp;
}
def code(A, B, C): tmp = 0 if B <= -3.4e-127: tmp = (math.atan(1.0) * 180.0) / math.pi else: tmp = (180.0 / math.pi) * math.atan(((C - B) / B)) return tmp
function code(A, B, C) tmp = 0.0 if (B <= -3.4e-127) tmp = Float64(Float64(atan(1.0) * 180.0) / pi); else tmp = Float64(Float64(180.0 / pi) * atan(Float64(Float64(C - B) / B))); end return tmp end
function tmp_2 = code(A, B, C) tmp = 0.0; if (B <= -3.4e-127) tmp = (atan(1.0) * 180.0) / pi; else tmp = (180.0 / pi) * atan(((C - B) / B)); end tmp_2 = tmp; end
code[A_, B_, C_] := If[LessEqual[B, -3.4e-127], N[(N[(N[ArcTan[1.0], $MachinePrecision] * 180.0), $MachinePrecision] / Pi), $MachinePrecision], N[(N[(180.0 / Pi), $MachinePrecision] * N[ArcTan[N[(N[(C - B), $MachinePrecision] / B), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq -3.4 \cdot 10^{-127}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{180}{\pi} \cdot \tan^{-1} \left(\frac{C - B}{B}\right)\\
\end{array}
\end{array}
if B < -3.3999999999999999e-127Initial program 49.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites75.4%
Applied rewrites73.9%
lift-+.f64N/A
Applied rewrites0.0%
Taylor expanded in B around -inf
Applied rewrites50.5%
if -3.3999999999999999e-127 < B Initial program 55.4%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites79.1%
Applied rewrites72.1%
Applied rewrites72.1%
Taylor expanded in B around inf
Applied rewrites51.8%
(FPCore (A B C) :precision binary64 (if (<= B -2.9e-305) (/ (* (atan 1.0) 180.0) PI) (/ (* (atan -1.0) 180.0) PI)))
double code(double A, double B, double C) {
double tmp;
if (B <= -2.9e-305) {
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 <= -2.9e-305) {
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 <= -2.9e-305: 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 <= -2.9e-305) 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 <= -2.9e-305) 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, -2.9e-305], 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 -2.9 \cdot 10^{-305}:\\
\;\;\;\;\frac{\tan^{-1} 1 \cdot 180}{\pi}\\
\mathbf{else}:\\
\;\;\;\;\frac{\tan^{-1} -1 \cdot 180}{\pi}\\
\end{array}
\end{array}
if B < -2.89999999999999988e-305Initial program 52.0%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.0%
Applied rewrites71.8%
lift-+.f64N/A
Applied rewrites0.0%
Taylor expanded in B around -inf
Applied rewrites39.9%
if -2.89999999999999988e-305 < B Initial program 54.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites78.6%
Applied rewrites73.6%
lift-+.f64N/A
Applied rewrites32.5%
Taylor expanded in B around inf
Applied rewrites39.9%
(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 53.3%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
Applied rewrites77.8%
Applied rewrites72.7%
lift-+.f64N/A
Applied rewrites16.3%
Taylor expanded in B around inf
Applied rewrites21.0%
herbie shell --seed 2025106
(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)))