
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) a))
(t_1 (* PI (/ (fabs angle) 180.0)))
(t_2 (+ a (fabs b))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 1.2e+80)
(*
(*
t_2
(* t_0 (* (sin (* (* PI 0.005555555555555556) (fabs angle))) 2.0)))
(cos t_1))
(if (<= (fabs angle) 5.4e+242)
(* (* (* t_2 (* t_0 2.0)) (sin t_1)) 1.0)
(*
(*
t_2
(* t_0 (* (sin (* (* 0.005555555555555556 (fabs angle)) PI)) 2.0)))
(cos (* -0.005555555555555556 (* PI (fabs angle))))))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - a;
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double t_2 = a + fabs(b);
double tmp;
if (fabs(angle) <= 1.2e+80) {
tmp = (t_2 * (t_0 * (sin(((((double) M_PI) * 0.005555555555555556) * fabs(angle))) * 2.0))) * cos(t_1);
} else if (fabs(angle) <= 5.4e+242) {
tmp = ((t_2 * (t_0 * 2.0)) * sin(t_1)) * 1.0;
} else {
tmp = (t_2 * (t_0 * (sin(((0.005555555555555556 * fabs(angle)) * ((double) M_PI))) * 2.0))) * cos((-0.005555555555555556 * (((double) M_PI) * fabs(angle))));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - a;
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double t_2 = a + Math.abs(b);
double tmp;
if (Math.abs(angle) <= 1.2e+80) {
tmp = (t_2 * (t_0 * (Math.sin(((Math.PI * 0.005555555555555556) * Math.abs(angle))) * 2.0))) * Math.cos(t_1);
} else if (Math.abs(angle) <= 5.4e+242) {
tmp = ((t_2 * (t_0 * 2.0)) * Math.sin(t_1)) * 1.0;
} else {
tmp = (t_2 * (t_0 * (Math.sin(((0.005555555555555556 * Math.abs(angle)) * Math.PI)) * 2.0))) * Math.cos((-0.005555555555555556 * (Math.PI * Math.abs(angle))));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - a t_1 = math.pi * (math.fabs(angle) / 180.0) t_2 = a + math.fabs(b) tmp = 0 if math.fabs(angle) <= 1.2e+80: tmp = (t_2 * (t_0 * (math.sin(((math.pi * 0.005555555555555556) * math.fabs(angle))) * 2.0))) * math.cos(t_1) elif math.fabs(angle) <= 5.4e+242: tmp = ((t_2 * (t_0 * 2.0)) * math.sin(t_1)) * 1.0 else: tmp = (t_2 * (t_0 * (math.sin(((0.005555555555555556 * math.fabs(angle)) * math.pi)) * 2.0))) * math.cos((-0.005555555555555556 * (math.pi * math.fabs(angle)))) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - a) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) t_2 = Float64(a + abs(b)) tmp = 0.0 if (abs(angle) <= 1.2e+80) tmp = Float64(Float64(t_2 * Float64(t_0 * Float64(sin(Float64(Float64(pi * 0.005555555555555556) * abs(angle))) * 2.0))) * cos(t_1)); elseif (abs(angle) <= 5.4e+242) tmp = Float64(Float64(Float64(t_2 * Float64(t_0 * 2.0)) * sin(t_1)) * 1.0); else tmp = Float64(Float64(t_2 * Float64(t_0 * Float64(sin(Float64(Float64(0.005555555555555556 * abs(angle)) * pi)) * 2.0))) * cos(Float64(-0.005555555555555556 * Float64(pi * abs(angle))))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - a; t_1 = pi * (abs(angle) / 180.0); t_2 = a + abs(b); tmp = 0.0; if (abs(angle) <= 1.2e+80) tmp = (t_2 * (t_0 * (sin(((pi * 0.005555555555555556) * abs(angle))) * 2.0))) * cos(t_1); elseif (abs(angle) <= 5.4e+242) tmp = ((t_2 * (t_0 * 2.0)) * sin(t_1)) * 1.0; else tmp = (t_2 * (t_0 * (sin(((0.005555555555555556 * abs(angle)) * pi)) * 2.0))) * cos((-0.005555555555555556 * (pi * abs(angle)))); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - a), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a + N[Abs[b], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 1.2e+80], N[(N[(t$95$2 * N[(t$95$0 * N[(N[Sin[N[(N[(Pi * 0.005555555555555556), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 5.4e+242], N[(N[(N[(t$95$2 * N[(t$95$0 * 2.0), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(N[(t$95$2 * N[(t$95$0 * N[(N[Sin[N[(N[(0.005555555555555556 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(-0.005555555555555556 * N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left|b\right| - a\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
t_2 := a + \left|b\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 1.2 \cdot 10^{+80}:\\
\;\;\;\;\left(t\_2 \cdot \left(t\_0 \cdot \left(\sin \left(\left(\pi \cdot 0.005555555555555556\right) \cdot \left|angle\right|\right) \cdot 2\right)\right)\right) \cdot \cos t\_1\\
\mathbf{elif}\;\left|angle\right| \leq 5.4 \cdot 10^{+242}:\\
\;\;\;\;\left(\left(t\_2 \cdot \left(t\_0 \cdot 2\right)\right) \cdot \sin t\_1\right) \cdot 1\\
\mathbf{else}:\\
\;\;\;\;\left(t\_2 \cdot \left(t\_0 \cdot \left(\sin \left(\left(0.005555555555555556 \cdot \left|angle\right|\right) \cdot \pi\right) \cdot 2\right)\right)\right) \cdot \cos \left(-0.005555555555555556 \cdot \left(\pi \cdot \left|angle\right|\right)\right)\\
\end{array}
\end{array}
if angle < 1.1999999999999999e80Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6466.8%
Applied rewrites66.8%
if 1.1999999999999999e80 < angle < 5.39999999999999968e242Initial program 53.4%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.3%
Applied rewrites57.3%
Taylor expanded in angle around 0
Applied rewrites56.3%
if 5.39999999999999968e242 < angle Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-cos.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
distribute-lft-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lower-*.f6466.6%
Applied rewrites66.6%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* PI (/ (fabs angle) 180.0)))
(t_1
(*
(+ a b)
(*
(- b a)
(* (sin (* (* 0.005555555555555556 (fabs angle)) PI)) 2.0)))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 1.65e+60)
(* t_1 (cos t_0))
(if (<= (fabs angle) 5.4e+242)
(* (* (* (+ a b) (* (- b a) 2.0)) (sin t_0)) 1.0)
(* t_1 (cos (* -0.005555555555555556 (* PI (fabs angle))))))))))double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (fabs(angle) / 180.0);
double t_1 = (a + b) * ((b - a) * (sin(((0.005555555555555556 * fabs(angle)) * ((double) M_PI))) * 2.0));
double tmp;
if (fabs(angle) <= 1.65e+60) {
tmp = t_1 * cos(t_0);
} else if (fabs(angle) <= 5.4e+242) {
tmp = (((a + b) * ((b - a) * 2.0)) * sin(t_0)) * 1.0;
} else {
tmp = t_1 * cos((-0.005555555555555556 * (((double) M_PI) * fabs(angle))));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (Math.abs(angle) / 180.0);
double t_1 = (a + b) * ((b - a) * (Math.sin(((0.005555555555555556 * Math.abs(angle)) * Math.PI)) * 2.0));
double tmp;
if (Math.abs(angle) <= 1.65e+60) {
tmp = t_1 * Math.cos(t_0);
} else if (Math.abs(angle) <= 5.4e+242) {
tmp = (((a + b) * ((b - a) * 2.0)) * Math.sin(t_0)) * 1.0;
} else {
tmp = t_1 * Math.cos((-0.005555555555555556 * (Math.PI * Math.abs(angle))));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.pi * (math.fabs(angle) / 180.0) t_1 = (a + b) * ((b - a) * (math.sin(((0.005555555555555556 * math.fabs(angle)) * math.pi)) * 2.0)) tmp = 0 if math.fabs(angle) <= 1.65e+60: tmp = t_1 * math.cos(t_0) elif math.fabs(angle) <= 5.4e+242: tmp = (((a + b) * ((b - a) * 2.0)) * math.sin(t_0)) * 1.0 else: tmp = t_1 * math.cos((-0.005555555555555556 * (math.pi * math.fabs(angle)))) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(pi * Float64(abs(angle) / 180.0)) t_1 = Float64(Float64(a + b) * Float64(Float64(b - a) * Float64(sin(Float64(Float64(0.005555555555555556 * abs(angle)) * pi)) * 2.0))) tmp = 0.0 if (abs(angle) <= 1.65e+60) tmp = Float64(t_1 * cos(t_0)); elseif (abs(angle) <= 5.4e+242) tmp = Float64(Float64(Float64(Float64(a + b) * Float64(Float64(b - a) * 2.0)) * sin(t_0)) * 1.0); else tmp = Float64(t_1 * cos(Float64(-0.005555555555555556 * Float64(pi * abs(angle))))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = pi * (abs(angle) / 180.0); t_1 = (a + b) * ((b - a) * (sin(((0.005555555555555556 * abs(angle)) * pi)) * 2.0)); tmp = 0.0; if (abs(angle) <= 1.65e+60) tmp = t_1 * cos(t_0); elseif (abs(angle) <= 5.4e+242) tmp = (((a + b) * ((b - a) * 2.0)) * sin(t_0)) * 1.0; else tmp = t_1 * cos((-0.005555555555555556 * (pi * abs(angle)))); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(a + b), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * N[(N[Sin[N[(N[(0.005555555555555556 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 1.65e+60], N[(t$95$1 * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 5.4e+242], N[(N[(N[(N[(a + b), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(t$95$1 * N[Cos[N[(-0.005555555555555556 * N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \pi \cdot \frac{\left|angle\right|}{180}\\
t_1 := \left(a + b\right) \cdot \left(\left(b - a\right) \cdot \left(\sin \left(\left(0.005555555555555556 \cdot \left|angle\right|\right) \cdot \pi\right) \cdot 2\right)\right)\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 1.65 \cdot 10^{+60}:\\
\;\;\;\;t\_1 \cdot \cos t\_0\\
\mathbf{elif}\;\left|angle\right| \leq 5.4 \cdot 10^{+242}:\\
\;\;\;\;\left(\left(\left(a + b\right) \cdot \left(\left(b - a\right) \cdot 2\right)\right) \cdot \sin t\_0\right) \cdot 1\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \cos \left(-0.005555555555555556 \cdot \left(\pi \cdot \left|angle\right|\right)\right)\\
\end{array}
\end{array}
if angle < 1.6499999999999999e60Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
if 1.6499999999999999e60 < angle < 5.39999999999999968e242Initial program 53.4%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.3%
Applied rewrites57.3%
Taylor expanded in angle around 0
Applied rewrites56.3%
if 5.39999999999999968e242 < angle Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-cos.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
distribute-lft-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lower-*.f6466.6%
Applied rewrites66.6%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (sin (* 0.011111111111111112 (* (fabs angle) PI))))
(t_1 (- (fabs b) (fabs a))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 5.6e+57)
(* t_1 (* (+ (fabs b) (fabs a)) t_0))
(if (<= (fabs angle) 3.6e+242)
(*
(*
(* (+ (fabs a) (fabs b)) (* t_1 2.0))
(sin (* PI (/ (fabs angle) 180.0))))
1.0)
(* (* (+ 1.0 (/ (fabs a) (fabs b))) (fabs b)) (* (fabs b) t_0)))))))double code(double a, double b, double angle) {
double t_0 = sin((0.011111111111111112 * (fabs(angle) * ((double) M_PI))));
double t_1 = fabs(b) - fabs(a);
double tmp;
if (fabs(angle) <= 5.6e+57) {
tmp = t_1 * ((fabs(b) + fabs(a)) * t_0);
} else if (fabs(angle) <= 3.6e+242) {
tmp = (((fabs(a) + fabs(b)) * (t_1 * 2.0)) * sin((((double) M_PI) * (fabs(angle) / 180.0)))) * 1.0;
} else {
tmp = ((1.0 + (fabs(a) / fabs(b))) * fabs(b)) * (fabs(b) * t_0);
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.sin((0.011111111111111112 * (Math.abs(angle) * Math.PI)));
double t_1 = Math.abs(b) - Math.abs(a);
double tmp;
if (Math.abs(angle) <= 5.6e+57) {
tmp = t_1 * ((Math.abs(b) + Math.abs(a)) * t_0);
} else if (Math.abs(angle) <= 3.6e+242) {
tmp = (((Math.abs(a) + Math.abs(b)) * (t_1 * 2.0)) * Math.sin((Math.PI * (Math.abs(angle) / 180.0)))) * 1.0;
} else {
tmp = ((1.0 + (Math.abs(a) / Math.abs(b))) * Math.abs(b)) * (Math.abs(b) * t_0);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.sin((0.011111111111111112 * (math.fabs(angle) * math.pi))) t_1 = math.fabs(b) - math.fabs(a) tmp = 0 if math.fabs(angle) <= 5.6e+57: tmp = t_1 * ((math.fabs(b) + math.fabs(a)) * t_0) elif math.fabs(angle) <= 3.6e+242: tmp = (((math.fabs(a) + math.fabs(b)) * (t_1 * 2.0)) * math.sin((math.pi * (math.fabs(angle) / 180.0)))) * 1.0 else: tmp = ((1.0 + (math.fabs(a) / math.fabs(b))) * math.fabs(b)) * (math.fabs(b) * t_0) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = sin(Float64(0.011111111111111112 * Float64(abs(angle) * pi))) t_1 = Float64(abs(b) - abs(a)) tmp = 0.0 if (abs(angle) <= 5.6e+57) tmp = Float64(t_1 * Float64(Float64(abs(b) + abs(a)) * t_0)); elseif (abs(angle) <= 3.6e+242) tmp = Float64(Float64(Float64(Float64(abs(a) + abs(b)) * Float64(t_1 * 2.0)) * sin(Float64(pi * Float64(abs(angle) / 180.0)))) * 1.0); else tmp = Float64(Float64(Float64(1.0 + Float64(abs(a) / abs(b))) * abs(b)) * Float64(abs(b) * t_0)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = sin((0.011111111111111112 * (abs(angle) * pi))); t_1 = abs(b) - abs(a); tmp = 0.0; if (abs(angle) <= 5.6e+57) tmp = t_1 * ((abs(b) + abs(a)) * t_0); elseif (abs(angle) <= 3.6e+242) tmp = (((abs(a) + abs(b)) * (t_1 * 2.0)) * sin((pi * (abs(angle) / 180.0)))) * 1.0; else tmp = ((1.0 + (abs(a) / abs(b))) * abs(b)) * (abs(b) * t_0); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[Sin[N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 5.6e+57], N[(t$95$1 * N[(N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 3.6e+242], N[(N[(N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(t$95$1 * 2.0), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(N[(N[(1.0 + N[(N[Abs[a], $MachinePrecision] / N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \sin \left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot \pi\right)\right)\\
t_1 := \left|b\right| - \left|a\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 5.6 \cdot 10^{+57}:\\
\;\;\;\;t\_1 \cdot \left(\left(\left|b\right| + \left|a\right|\right) \cdot t\_0\right)\\
\mathbf{elif}\;\left|angle\right| \leq 3.6 \cdot 10^{+242}:\\
\;\;\;\;\left(\left(\left(\left|a\right| + \left|b\right|\right) \cdot \left(t\_1 \cdot 2\right)\right) \cdot \sin \left(\pi \cdot \frac{\left|angle\right|}{180}\right)\right) \cdot 1\\
\mathbf{else}:\\
\;\;\;\;\left(\left(1 + \frac{\left|a\right|}{\left|b\right|}\right) \cdot \left|b\right|\right) \cdot \left(\left|b\right| \cdot t\_0\right)\\
\end{array}
\end{array}
if angle < 5.59999999999999999e57Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.0%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
if 5.59999999999999999e57 < angle < 3.59999999999999995e242Initial program 53.4%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.3%
Applied rewrites57.3%
Taylor expanded in angle around 0
Applied rewrites56.3%
if 3.59999999999999995e242 < angle Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
lift-+.f64N/A
+-commutativeN/A
sum-to-multN/A
lower-unsound-*.f64N/A
lower-unsound-+.f64N/A
lower-unsound-/.f6444.8%
Applied rewrites44.8%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 6.5e+130)
(*
(*
(+ (fabs a) (fabs b))
(*
(- (fabs b) (fabs a))
(* (sin (* (* 0.005555555555555556 (fabs angle)) PI)) 2.0)))
1.0)
(if (<= (fabs angle) 4.2e+207)
(*
0.011111111111111112
(*
(fabs angle)
(* PI (fma (- (fabs a)) (fabs a) (* (fabs b) (fabs b))))))
(*
(* (+ 1.0 (/ (fabs a) (fabs b))) (fabs b))
(* (fabs b) (sin (* 0.011111111111111112 (* (fabs angle) PI)))))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 6.5e+130) {
tmp = ((fabs(a) + fabs(b)) * ((fabs(b) - fabs(a)) * (sin(((0.005555555555555556 * fabs(angle)) * ((double) M_PI))) * 2.0))) * 1.0;
} else if (fabs(angle) <= 4.2e+207) {
tmp = 0.011111111111111112 * (fabs(angle) * (((double) M_PI) * fma(-fabs(a), fabs(a), (fabs(b) * fabs(b)))));
} else {
tmp = ((1.0 + (fabs(a) / fabs(b))) * fabs(b)) * (fabs(b) * sin((0.011111111111111112 * (fabs(angle) * ((double) M_PI)))));
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 6.5e+130) tmp = Float64(Float64(Float64(abs(a) + abs(b)) * Float64(Float64(abs(b) - abs(a)) * Float64(sin(Float64(Float64(0.005555555555555556 * abs(angle)) * pi)) * 2.0))) * 1.0); elseif (abs(angle) <= 4.2e+207) tmp = Float64(0.011111111111111112 * Float64(abs(angle) * Float64(pi * fma(Float64(-abs(a)), abs(a), Float64(abs(b) * abs(b)))))); else tmp = Float64(Float64(Float64(1.0 + Float64(abs(a) / abs(b))) * abs(b)) * Float64(abs(b) * sin(Float64(0.011111111111111112 * Float64(abs(angle) * pi))))); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 6.5e+130], N[(N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(N[(0.005555555555555556 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 4.2e+207], N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(Pi * N[((-N[Abs[a], $MachinePrecision]) * N[Abs[a], $MachinePrecision] + N[(N[Abs[b], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[(N[Abs[a], $MachinePrecision] / N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 6.5 \cdot 10^{+130}:\\
\;\;\;\;\left(\left(\left|a\right| + \left|b\right|\right) \cdot \left(\left(\left|b\right| - \left|a\right|\right) \cdot \left(\sin \left(\left(0.005555555555555556 \cdot \left|angle\right|\right) \cdot \pi\right) \cdot 2\right)\right)\right) \cdot 1\\
\mathbf{elif}\;\left|angle\right| \leq 4.2 \cdot 10^{+207}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\pi \cdot \mathsf{fma}\left(-\left|a\right|, \left|a\right|, \left|b\right| \cdot \left|b\right|\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(1 + \frac{\left|a\right|}{\left|b\right|}\right) \cdot \left|b\right|\right) \cdot \left(\left|b\right| \cdot \sin \left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot \pi\right)\right)\right)\\
\end{array}
if angle < 6.5e130Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
Taylor expanded in angle around 0
Applied rewrites66.0%
if 6.5e130 < angle < 4.1999999999999999e207Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6453.2%
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.2%
Applied rewrites53.2%
if 4.1999999999999999e207 < angle Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
lift-+.f64N/A
+-commutativeN/A
sum-to-multN/A
lower-unsound-*.f64N/A
lower-unsound-+.f64N/A
lower-unsound-/.f6444.8%
Applied rewrites44.8%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (sin (* 0.011111111111111112 (* (fabs angle) PI)))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.1e+110)
(* (- (fabs b) (fabs a)) (* (+ (fabs b) (fabs a)) t_0))
(if (<= (fabs angle) 4.2e+207)
(*
0.011111111111111112
(*
(fabs angle)
(* PI (fma (- (fabs a)) (fabs a) (* (fabs b) (fabs b))))))
(* (* (+ 1.0 (/ (fabs a) (fabs b))) (fabs b)) (* (fabs b) t_0)))))))double code(double a, double b, double angle) {
double t_0 = sin((0.011111111111111112 * (fabs(angle) * ((double) M_PI))));
double tmp;
if (fabs(angle) <= 2.1e+110) {
tmp = (fabs(b) - fabs(a)) * ((fabs(b) + fabs(a)) * t_0);
} else if (fabs(angle) <= 4.2e+207) {
tmp = 0.011111111111111112 * (fabs(angle) * (((double) M_PI) * fma(-fabs(a), fabs(a), (fabs(b) * fabs(b)))));
} else {
tmp = ((1.0 + (fabs(a) / fabs(b))) * fabs(b)) * (fabs(b) * t_0);
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) t_0 = sin(Float64(0.011111111111111112 * Float64(abs(angle) * pi))) tmp = 0.0 if (abs(angle) <= 2.1e+110) tmp = Float64(Float64(abs(b) - abs(a)) * Float64(Float64(abs(b) + abs(a)) * t_0)); elseif (abs(angle) <= 4.2e+207) tmp = Float64(0.011111111111111112 * Float64(abs(angle) * Float64(pi * fma(Float64(-abs(a)), abs(a), Float64(abs(b) * abs(b)))))); else tmp = Float64(Float64(Float64(1.0 + Float64(abs(a) / abs(b))) * abs(b)) * Float64(abs(b) * t_0)); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := Block[{t$95$0 = N[Sin[N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.1e+110], N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 4.2e+207], N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(Pi * N[((-N[Abs[a], $MachinePrecision]) * N[Abs[a], $MachinePrecision] + N[(N[Abs[b], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[(N[Abs[a], $MachinePrecision] / N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \sin \left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot \pi\right)\right)\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.1 \cdot 10^{+110}:\\
\;\;\;\;\left(\left|b\right| - \left|a\right|\right) \cdot \left(\left(\left|b\right| + \left|a\right|\right) \cdot t\_0\right)\\
\mathbf{elif}\;\left|angle\right| \leq 4.2 \cdot 10^{+207}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\pi \cdot \mathsf{fma}\left(-\left|a\right|, \left|a\right|, \left|b\right| \cdot \left|b\right|\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(1 + \frac{\left|a\right|}{\left|b\right|}\right) \cdot \left|b\right|\right) \cdot \left(\left|b\right| \cdot t\_0\right)\\
\end{array}
\end{array}
if angle < 2.10000000000000015e110Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.0%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
if 2.10000000000000015e110 < angle < 4.1999999999999999e207Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6453.2%
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.2%
Applied rewrites53.2%
if 4.1999999999999999e207 < angle Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
lift-+.f64N/A
+-commutativeN/A
sum-to-multN/A
lower-unsound-*.f64N/A
lower-unsound-+.f64N/A
lower-unsound-/.f6444.8%
Applied rewrites44.8%
(FPCore (a b angle)
:precision binary64
(let* ((t_0
(*
(+ (fabs a) b)
(*
(- b (fabs a))
(* (sin (/ 0.005555555555555556 (/ 1.0 (* angle PI)))) 2.0)))))
(if (<= (fabs a) 6e+159)
(* t_0 (cos (* (* PI angle) 0.005555555555555556)))
(* t_0 1.0))))double code(double a, double b, double angle) {
double t_0 = (fabs(a) + b) * ((b - fabs(a)) * (sin((0.005555555555555556 / (1.0 / (angle * ((double) M_PI))))) * 2.0));
double tmp;
if (fabs(a) <= 6e+159) {
tmp = t_0 * cos(((((double) M_PI) * angle) * 0.005555555555555556));
} else {
tmp = t_0 * 1.0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = (Math.abs(a) + b) * ((b - Math.abs(a)) * (Math.sin((0.005555555555555556 / (1.0 / (angle * Math.PI)))) * 2.0));
double tmp;
if (Math.abs(a) <= 6e+159) {
tmp = t_0 * Math.cos(((Math.PI * angle) * 0.005555555555555556));
} else {
tmp = t_0 * 1.0;
}
return tmp;
}
def code(a, b, angle): t_0 = (math.fabs(a) + b) * ((b - math.fabs(a)) * (math.sin((0.005555555555555556 / (1.0 / (angle * math.pi)))) * 2.0)) tmp = 0 if math.fabs(a) <= 6e+159: tmp = t_0 * math.cos(((math.pi * angle) * 0.005555555555555556)) else: tmp = t_0 * 1.0 return tmp
function code(a, b, angle) t_0 = Float64(Float64(abs(a) + b) * Float64(Float64(b - abs(a)) * Float64(sin(Float64(0.005555555555555556 / Float64(1.0 / Float64(angle * pi)))) * 2.0))) tmp = 0.0 if (abs(a) <= 6e+159) tmp = Float64(t_0 * cos(Float64(Float64(pi * angle) * 0.005555555555555556))); else tmp = Float64(t_0 * 1.0); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = (abs(a) + b) * ((b - abs(a)) * (sin((0.005555555555555556 / (1.0 / (angle * pi)))) * 2.0)); tmp = 0.0; if (abs(a) <= 6e+159) tmp = t_0 * cos(((pi * angle) * 0.005555555555555556)); else tmp = t_0 * 1.0; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(N[Abs[a], $MachinePrecision] + b), $MachinePrecision] * N[(N[(b - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(0.005555555555555556 / N[(1.0 / N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Abs[a], $MachinePrecision], 6e+159], N[(t$95$0 * N[Cos[N[(N[(Pi * angle), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$0 * 1.0), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left(\left|a\right| + b\right) \cdot \left(\left(b - \left|a\right|\right) \cdot \left(\sin \left(\frac{0.005555555555555556}{\frac{1}{angle \cdot \pi}}\right) \cdot 2\right)\right)\\
\mathbf{if}\;\left|a\right| \leq 6 \cdot 10^{+159}:\\
\;\;\;\;t\_0 \cdot \cos \left(\left(\pi \cdot angle\right) \cdot 0.005555555555555556\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot 1\\
\end{array}
if a < 6.0000000000000004e159Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
div-flipN/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-*.f6466.7%
Applied rewrites66.7%
lift-/.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-/r*N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
associate-*r/N/A
*-commutativeN/A
lift-*.f64N/A
mult-flipN/A
metadata-evalN/A
lower-*.f6466.8%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6466.8%
Applied rewrites66.8%
if 6.0000000000000004e159 < a Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
div-flipN/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-*.f6466.7%
Applied rewrites66.7%
lift-/.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-/r*N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
Taylor expanded in angle around 0
Applied rewrites65.3%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (+ a (fabs b))) (t_1 (- (fabs b) a)))
(if (<= (fabs b) 6.5e+257)
(*
(* t_0 (* t_1 (* (sin (* (* 0.005555555555555556 angle) PI)) 2.0)))
(cos (* -0.005555555555555556 (* PI angle))))
(*
(*
t_0
(* t_1 (* (sin (/ 0.005555555555555556 (/ 1.0 (* angle PI)))) 2.0)))
1.0))))double code(double a, double b, double angle) {
double t_0 = a + fabs(b);
double t_1 = fabs(b) - a;
double tmp;
if (fabs(b) <= 6.5e+257) {
tmp = (t_0 * (t_1 * (sin(((0.005555555555555556 * angle) * ((double) M_PI))) * 2.0))) * cos((-0.005555555555555556 * (((double) M_PI) * angle)));
} else {
tmp = (t_0 * (t_1 * (sin((0.005555555555555556 / (1.0 / (angle * ((double) M_PI))))) * 2.0))) * 1.0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = a + Math.abs(b);
double t_1 = Math.abs(b) - a;
double tmp;
if (Math.abs(b) <= 6.5e+257) {
tmp = (t_0 * (t_1 * (Math.sin(((0.005555555555555556 * angle) * Math.PI)) * 2.0))) * Math.cos((-0.005555555555555556 * (Math.PI * angle)));
} else {
tmp = (t_0 * (t_1 * (Math.sin((0.005555555555555556 / (1.0 / (angle * Math.PI)))) * 2.0))) * 1.0;
}
return tmp;
}
def code(a, b, angle): t_0 = a + math.fabs(b) t_1 = math.fabs(b) - a tmp = 0 if math.fabs(b) <= 6.5e+257: tmp = (t_0 * (t_1 * (math.sin(((0.005555555555555556 * angle) * math.pi)) * 2.0))) * math.cos((-0.005555555555555556 * (math.pi * angle))) else: tmp = (t_0 * (t_1 * (math.sin((0.005555555555555556 / (1.0 / (angle * math.pi)))) * 2.0))) * 1.0 return tmp
function code(a, b, angle) t_0 = Float64(a + abs(b)) t_1 = Float64(abs(b) - a) tmp = 0.0 if (abs(b) <= 6.5e+257) tmp = Float64(Float64(t_0 * Float64(t_1 * Float64(sin(Float64(Float64(0.005555555555555556 * angle) * pi)) * 2.0))) * cos(Float64(-0.005555555555555556 * Float64(pi * angle)))); else tmp = Float64(Float64(t_0 * Float64(t_1 * Float64(sin(Float64(0.005555555555555556 / Float64(1.0 / Float64(angle * pi)))) * 2.0))) * 1.0); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = a + abs(b); t_1 = abs(b) - a; tmp = 0.0; if (abs(b) <= 6.5e+257) tmp = (t_0 * (t_1 * (sin(((0.005555555555555556 * angle) * pi)) * 2.0))) * cos((-0.005555555555555556 * (pi * angle))); else tmp = (t_0 * (t_1 * (sin((0.005555555555555556 / (1.0 / (angle * pi)))) * 2.0))) * 1.0; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(a + N[Abs[b], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Abs[b], $MachinePrecision] - a), $MachinePrecision]}, If[LessEqual[N[Abs[b], $MachinePrecision], 6.5e+257], N[(N[(t$95$0 * N[(t$95$1 * N[(N[Sin[N[(N[(0.005555555555555556 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(-0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(t$95$0 * N[(t$95$1 * N[(N[Sin[N[(0.005555555555555556 / N[(1.0 / N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]]]
\begin{array}{l}
t_0 := a + \left|b\right|\\
t_1 := \left|b\right| - a\\
\mathbf{if}\;\left|b\right| \leq 6.5 \cdot 10^{+257}:\\
\;\;\;\;\left(t\_0 \cdot \left(t\_1 \cdot \left(\sin \left(\left(0.005555555555555556 \cdot angle\right) \cdot \pi\right) \cdot 2\right)\right)\right) \cdot \cos \left(-0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t\_0 \cdot \left(t\_1 \cdot \left(\sin \left(\frac{0.005555555555555556}{\frac{1}{angle \cdot \pi}}\right) \cdot 2\right)\right)\right) \cdot 1\\
\end{array}
if b < 6.50000000000000026e257Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-cos.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
distribute-lft-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lower-*.f6466.6%
Applied rewrites66.6%
if 6.50000000000000026e257 < b Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
div-flipN/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-*.f6466.7%
Applied rewrites66.7%
lift-/.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-/r*N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
Taylor expanded in angle around 0
Applied rewrites65.3%
(FPCore (a b angle) :precision binary64 (* (* (+ a b) (* (- b a) (* (sin (/ 0.005555555555555556 (/ 1.0 (* angle PI)))) 2.0))) (cos (* PI (/ angle 180.0)))))
double code(double a, double b, double angle) {
return ((a + b) * ((b - a) * (sin((0.005555555555555556 / (1.0 / (angle * ((double) M_PI))))) * 2.0))) * cos((((double) M_PI) * (angle / 180.0)));
}
public static double code(double a, double b, double angle) {
return ((a + b) * ((b - a) * (Math.sin((0.005555555555555556 / (1.0 / (angle * Math.PI)))) * 2.0))) * Math.cos((Math.PI * (angle / 180.0)));
}
def code(a, b, angle): return ((a + b) * ((b - a) * (math.sin((0.005555555555555556 / (1.0 / (angle * math.pi)))) * 2.0))) * math.cos((math.pi * (angle / 180.0)))
function code(a, b, angle) return Float64(Float64(Float64(a + b) * Float64(Float64(b - a) * Float64(sin(Float64(0.005555555555555556 / Float64(1.0 / Float64(angle * pi)))) * 2.0))) * cos(Float64(pi * Float64(angle / 180.0)))) end
function tmp = code(a, b, angle) tmp = ((a + b) * ((b - a) * (sin((0.005555555555555556 / (1.0 / (angle * pi)))) * 2.0))) * cos((pi * (angle / 180.0))); end
code[a_, b_, angle_] := N[(N[(N[(a + b), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * N[(N[Sin[N[(0.005555555555555556 / N[(1.0 / N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\left(\left(a + b\right) \cdot \left(\left(b - a\right) \cdot \left(\sin \left(\frac{0.005555555555555556}{\frac{1}{angle \cdot \pi}}\right) \cdot 2\right)\right)\right) \cdot \cos \left(\pi \cdot \frac{angle}{180}\right)
Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
div-flipN/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-*.f6466.7%
Applied rewrites66.7%
lift-/.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-/r*N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 5e-42)
(* (* (* (* 0.011111111111111112 (fabs angle)) (+ b a)) PI) (- b a))
(if (<= (fabs angle) 2.1e+110)
(*
(* (- b a) (+ a b))
(sin (* (* (fabs angle) PI) 0.011111111111111112)))
(*
0.011111111111111112
(* (fabs angle) (* PI (fma (- a) a (* b b)))))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 5e-42) {
tmp = (((0.011111111111111112 * fabs(angle)) * (b + a)) * ((double) M_PI)) * (b - a);
} else if (fabs(angle) <= 2.1e+110) {
tmp = ((b - a) * (a + b)) * sin(((fabs(angle) * ((double) M_PI)) * 0.011111111111111112));
} else {
tmp = 0.011111111111111112 * (fabs(angle) * (((double) M_PI) * fma(-a, a, (b * b))));
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 5e-42) tmp = Float64(Float64(Float64(Float64(0.011111111111111112 * abs(angle)) * Float64(b + a)) * pi) * Float64(b - a)); elseif (abs(angle) <= 2.1e+110) tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * sin(Float64(Float64(abs(angle) * pi) * 0.011111111111111112))); else tmp = Float64(0.011111111111111112 * Float64(abs(angle) * Float64(pi * fma(Float64(-a), a, Float64(b * b))))); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 5e-42], N[(N[(N[(N[(0.011111111111111112 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(b + a), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Abs[angle], $MachinePrecision], 2.1e+110], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(Pi * N[((-a) * a + N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 5 \cdot 10^{-42}:\\
\;\;\;\;\left(\left(\left(0.011111111111111112 \cdot \left|angle\right|\right) \cdot \left(b + a\right)\right) \cdot \pi\right) \cdot \left(b - a\right)\\
\mathbf{elif}\;\left|angle\right| \leq 2.1 \cdot 10^{+110}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \sin \left(\left(\left|angle\right| \cdot \pi\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\pi \cdot \mathsf{fma}\left(-a, a, b \cdot b\right)\right)\right)\\
\end{array}
if angle < 5.00000000000000003e-42Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-*.f6462.3%
lift-+.f64N/A
+-commutativeN/A
lift-+.f6462.3%
Applied rewrites62.3%
if 5.00000000000000003e-42 < angle < 2.10000000000000015e110Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites57.3%
if 2.10000000000000015e110 < angle Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6453.2%
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.2%
Applied rewrites53.2%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.1e+110)
(*
(- (fabs b) a)
(* (+ (fabs b) a) (sin (* 0.011111111111111112 (* (fabs angle) PI)))))
(*
0.011111111111111112
(* (fabs angle) (* PI (fma (- a) a (* (fabs b) (fabs b)))))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 2.1e+110) {
tmp = (fabs(b) - a) * ((fabs(b) + a) * sin((0.011111111111111112 * (fabs(angle) * ((double) M_PI)))));
} else {
tmp = 0.011111111111111112 * (fabs(angle) * (((double) M_PI) * fma(-a, a, (fabs(b) * fabs(b)))));
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 2.1e+110) tmp = Float64(Float64(abs(b) - a) * Float64(Float64(abs(b) + a) * sin(Float64(0.011111111111111112 * Float64(abs(angle) * pi))))); else tmp = Float64(0.011111111111111112 * Float64(abs(angle) * Float64(pi * fma(Float64(-a), a, Float64(abs(b) * abs(b)))))); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.1e+110], N[(N[(N[Abs[b], $MachinePrecision] - a), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] + a), $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(Pi * N[((-a) * a + N[(N[Abs[b], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.1 \cdot 10^{+110}:\\
\;\;\;\;\left(\left|b\right| - a\right) \cdot \left(\left(\left|b\right| + a\right) \cdot \sin \left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\pi \cdot \mathsf{fma}\left(-a, a, \left|b\right| \cdot \left|b\right|\right)\right)\right)\\
\end{array}
if angle < 2.10000000000000015e110Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.0%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
if 2.10000000000000015e110 < angle Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6453.2%
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.2%
Applied rewrites53.2%
(FPCore (a b angle) :precision binary64 (* (* (+ a b) (* (- b a) (* (sin (/ 0.005555555555555556 (/ 1.0 (* angle PI)))) 2.0))) 1.0))
double code(double a, double b, double angle) {
return ((a + b) * ((b - a) * (sin((0.005555555555555556 / (1.0 / (angle * ((double) M_PI))))) * 2.0))) * 1.0;
}
public static double code(double a, double b, double angle) {
return ((a + b) * ((b - a) * (Math.sin((0.005555555555555556 / (1.0 / (angle * Math.PI)))) * 2.0))) * 1.0;
}
def code(a, b, angle): return ((a + b) * ((b - a) * (math.sin((0.005555555555555556 / (1.0 / (angle * math.pi)))) * 2.0))) * 1.0
function code(a, b, angle) return Float64(Float64(Float64(a + b) * Float64(Float64(b - a) * Float64(sin(Float64(0.005555555555555556 / Float64(1.0 / Float64(angle * pi)))) * 2.0))) * 1.0) end
function tmp = code(a, b, angle) tmp = ((a + b) * ((b - a) * (sin((0.005555555555555556 / (1.0 / (angle * pi)))) * 2.0))) * 1.0; end
code[a_, b_, angle_] := N[(N[(N[(a + b), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * N[(N[Sin[N[(0.005555555555555556 / N[(1.0 / N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]
\left(\left(a + b\right) \cdot \left(\left(b - a\right) \cdot \left(\sin \left(\frac{0.005555555555555556}{\frac{1}{angle \cdot \pi}}\right) \cdot 2\right)\right)\right) \cdot 1
Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.0%
Applied rewrites66.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
div-flipN/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-unsound-/.f64N/A
*-commutativeN/A
lower-*.f6466.7%
Applied rewrites66.7%
lift-/.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-/r*N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6467.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6467.0%
Applied rewrites67.0%
Taylor expanded in angle around 0
Applied rewrites65.3%
(FPCore (a b angle) :precision binary64 (* (+ a b) (* (- b a) (sin (* (* 0.011111111111111112 angle) PI)))))
double code(double a, double b, double angle) {
return (a + b) * ((b - a) * sin(((0.011111111111111112 * angle) * ((double) M_PI))));
}
public static double code(double a, double b, double angle) {
return (a + b) * ((b - a) * Math.sin(((0.011111111111111112 * angle) * Math.PI)));
}
def code(a, b, angle): return (a + b) * ((b - a) * math.sin(((0.011111111111111112 * angle) * math.pi)))
function code(a, b, angle) return Float64(Float64(a + b) * Float64(Float64(b - a) * sin(Float64(Float64(0.011111111111111112 * angle) * pi)))) end
function tmp = code(a, b, angle) tmp = (a + b) * ((b - a) * sin(((0.011111111111111112 * angle) * pi))); end
code[a_, b_, angle_] := N[(N[(a + b), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\left(a + b\right) \cdot \left(\left(b - a\right) \cdot \sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right)\right)
Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6466.6%
Applied rewrites66.6%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (+ (fabs b) (fabs a))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.2e+190)
(*
(* (* (fabs angle) t_0) (- (fabs b) (fabs a)))
(* 0.011111111111111112 PI))
(* (* 0.011111111111111112 (fabs angle)) (* t_0 (* (fabs b) PI)))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) + fabs(a);
double tmp;
if (fabs(angle) <= 2.2e+190) {
tmp = ((fabs(angle) * t_0) * (fabs(b) - fabs(a))) * (0.011111111111111112 * ((double) M_PI));
} else {
tmp = (0.011111111111111112 * fabs(angle)) * (t_0 * (fabs(b) * ((double) M_PI)));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) + Math.abs(a);
double tmp;
if (Math.abs(angle) <= 2.2e+190) {
tmp = ((Math.abs(angle) * t_0) * (Math.abs(b) - Math.abs(a))) * (0.011111111111111112 * Math.PI);
} else {
tmp = (0.011111111111111112 * Math.abs(angle)) * (t_0 * (Math.abs(b) * Math.PI));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) + math.fabs(a) tmp = 0 if math.fabs(angle) <= 2.2e+190: tmp = ((math.fabs(angle) * t_0) * (math.fabs(b) - math.fabs(a))) * (0.011111111111111112 * math.pi) else: tmp = (0.011111111111111112 * math.fabs(angle)) * (t_0 * (math.fabs(b) * math.pi)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) + abs(a)) tmp = 0.0 if (abs(angle) <= 2.2e+190) tmp = Float64(Float64(Float64(abs(angle) * t_0) * Float64(abs(b) - abs(a))) * Float64(0.011111111111111112 * pi)); else tmp = Float64(Float64(0.011111111111111112 * abs(angle)) * Float64(t_0 * Float64(abs(b) * pi))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) + abs(a); tmp = 0.0; if (abs(angle) <= 2.2e+190) tmp = ((abs(angle) * t_0) * (abs(b) - abs(a))) * (0.011111111111111112 * pi); else tmp = (0.011111111111111112 * abs(angle)) * (t_0 * (abs(b) * pi)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.2e+190], N[(N[(N[(N[Abs[angle], $MachinePrecision] * t$95$0), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(0.011111111111111112 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left|b\right| + \left|a\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.2 \cdot 10^{+190}:\\
\;\;\;\;\left(\left(\left|angle\right| \cdot t\_0\right) \cdot \left(\left|b\right| - \left|a\right|\right)\right) \cdot \left(0.011111111111111112 \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left|angle\right|\right) \cdot \left(t\_0 \cdot \left(\left|b\right| \cdot \pi\right)\right)\\
\end{array}
\end{array}
if angle < 2.2e190Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6462.3%
Applied rewrites62.3%
if 2.2e190 < angle Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
Taylor expanded in a around 0
lower-*.f64N/A
lower-PI.f6437.3%
Applied rewrites37.3%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (+ (fabs b) (fabs a))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.2e+190)
(*
(* (* 0.011111111111111112 (* (fabs angle) (- (fabs b) (fabs a)))) t_0)
PI)
(* (* 0.011111111111111112 (fabs angle)) (* t_0 (* (fabs b) PI)))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) + fabs(a);
double tmp;
if (fabs(angle) <= 2.2e+190) {
tmp = ((0.011111111111111112 * (fabs(angle) * (fabs(b) - fabs(a)))) * t_0) * ((double) M_PI);
} else {
tmp = (0.011111111111111112 * fabs(angle)) * (t_0 * (fabs(b) * ((double) M_PI)));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) + Math.abs(a);
double tmp;
if (Math.abs(angle) <= 2.2e+190) {
tmp = ((0.011111111111111112 * (Math.abs(angle) * (Math.abs(b) - Math.abs(a)))) * t_0) * Math.PI;
} else {
tmp = (0.011111111111111112 * Math.abs(angle)) * (t_0 * (Math.abs(b) * Math.PI));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) + math.fabs(a) tmp = 0 if math.fabs(angle) <= 2.2e+190: tmp = ((0.011111111111111112 * (math.fabs(angle) * (math.fabs(b) - math.fabs(a)))) * t_0) * math.pi else: tmp = (0.011111111111111112 * math.fabs(angle)) * (t_0 * (math.fabs(b) * math.pi)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) + abs(a)) tmp = 0.0 if (abs(angle) <= 2.2e+190) tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(abs(angle) * Float64(abs(b) - abs(a)))) * t_0) * pi); else tmp = Float64(Float64(0.011111111111111112 * abs(angle)) * Float64(t_0 * Float64(abs(b) * pi))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) + abs(a); tmp = 0.0; if (abs(angle) <= 2.2e+190) tmp = ((0.011111111111111112 * (abs(angle) * (abs(b) - abs(a)))) * t_0) * pi; else tmp = (0.011111111111111112 * abs(angle)) * (t_0 * (abs(b) * pi)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.2e+190], N[(N[(N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * Pi), $MachinePrecision], N[(N[(0.011111111111111112 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left|b\right| + \left|a\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.2 \cdot 10^{+190}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\left|b\right| - \left|a\right|\right)\right)\right) \cdot t\_0\right) \cdot \pi\\
\mathbf{else}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left|angle\right|\right) \cdot \left(t\_0 \cdot \left(\left|b\right| \cdot \pi\right)\right)\\
\end{array}
\end{array}
if angle < 2.2e190Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6462.3%
Applied rewrites62.3%
if 2.2e190 < angle Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
Taylor expanded in a around 0
lower-*.f64N/A
lower-PI.f6437.3%
Applied rewrites37.3%
(FPCore (a b angle)
:precision binary64
(if (<= (fabs b) 3.8e+195)
(*
(* PI angle)
(* (* (- (fabs b) (fabs a)) (+ (fabs b) (fabs a))) 0.011111111111111112))
(*
(+ (fabs a) (fabs b))
(* 0.011111111111111112 (* angle (* (fabs b) PI))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(b) <= 3.8e+195) {
tmp = (((double) M_PI) * angle) * (((fabs(b) - fabs(a)) * (fabs(b) + fabs(a))) * 0.011111111111111112);
} else {
tmp = (fabs(a) + fabs(b)) * (0.011111111111111112 * (angle * (fabs(b) * ((double) M_PI))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(b) <= 3.8e+195) {
tmp = (Math.PI * angle) * (((Math.abs(b) - Math.abs(a)) * (Math.abs(b) + Math.abs(a))) * 0.011111111111111112);
} else {
tmp = (Math.abs(a) + Math.abs(b)) * (0.011111111111111112 * (angle * (Math.abs(b) * Math.PI)));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(b) <= 3.8e+195: tmp = (math.pi * angle) * (((math.fabs(b) - math.fabs(a)) * (math.fabs(b) + math.fabs(a))) * 0.011111111111111112) else: tmp = (math.fabs(a) + math.fabs(b)) * (0.011111111111111112 * (angle * (math.fabs(b) * math.pi))) return tmp
function code(a, b, angle) tmp = 0.0 if (abs(b) <= 3.8e+195) tmp = Float64(Float64(pi * angle) * Float64(Float64(Float64(abs(b) - abs(a)) * Float64(abs(b) + abs(a))) * 0.011111111111111112)); else tmp = Float64(Float64(abs(a) + abs(b)) * Float64(0.011111111111111112 * Float64(angle * Float64(abs(b) * pi)))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(b) <= 3.8e+195) tmp = (pi * angle) * (((abs(b) - abs(a)) * (abs(b) + abs(a))) * 0.011111111111111112); else tmp = (abs(a) + abs(b)) * (0.011111111111111112 * (angle * (abs(b) * pi))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Abs[b], $MachinePrecision], 3.8e+195], N[(N[(Pi * angle), $MachinePrecision] * N[(N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;\left|b\right| \leq 3.8 \cdot 10^{+195}:\\
\;\;\;\;\left(\pi \cdot angle\right) \cdot \left(\left(\left(\left|b\right| - \left|a\right|\right) \cdot \left(\left|b\right| + \left|a\right|\right)\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left|a\right| + \left|b\right|\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\left|b\right| \cdot \pi\right)\right)\right)\\
\end{array}
if b < 3.8e195Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
if 3.8e195 < b Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6439.9%
Applied rewrites39.9%
(FPCore (a b angle)
:precision binary64
(if (<= (fabs b) 3.8e+195)
(*
(* 0.011111111111111112 angle)
(* (+ (fabs b) (fabs a)) (* (- (fabs b) (fabs a)) PI)))
(*
(+ (fabs a) (fabs b))
(* 0.011111111111111112 (* angle (* (fabs b) PI))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(b) <= 3.8e+195) {
tmp = (0.011111111111111112 * angle) * ((fabs(b) + fabs(a)) * ((fabs(b) - fabs(a)) * ((double) M_PI)));
} else {
tmp = (fabs(a) + fabs(b)) * (0.011111111111111112 * (angle * (fabs(b) * ((double) M_PI))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(b) <= 3.8e+195) {
tmp = (0.011111111111111112 * angle) * ((Math.abs(b) + Math.abs(a)) * ((Math.abs(b) - Math.abs(a)) * Math.PI));
} else {
tmp = (Math.abs(a) + Math.abs(b)) * (0.011111111111111112 * (angle * (Math.abs(b) * Math.PI)));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(b) <= 3.8e+195: tmp = (0.011111111111111112 * angle) * ((math.fabs(b) + math.fabs(a)) * ((math.fabs(b) - math.fabs(a)) * math.pi)) else: tmp = (math.fabs(a) + math.fabs(b)) * (0.011111111111111112 * (angle * (math.fabs(b) * math.pi))) return tmp
function code(a, b, angle) tmp = 0.0 if (abs(b) <= 3.8e+195) tmp = Float64(Float64(0.011111111111111112 * angle) * Float64(Float64(abs(b) + abs(a)) * Float64(Float64(abs(b) - abs(a)) * pi))); else tmp = Float64(Float64(abs(a) + abs(b)) * Float64(0.011111111111111112 * Float64(angle * Float64(abs(b) * pi)))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(b) <= 3.8e+195) tmp = (0.011111111111111112 * angle) * ((abs(b) + abs(a)) * ((abs(b) - abs(a)) * pi)); else tmp = (abs(a) + abs(b)) * (0.011111111111111112 * (angle * (abs(b) * pi))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Abs[b], $MachinePrecision], 3.8e+195], N[(N[(0.011111111111111112 * angle), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;\left|b\right| \leq 3.8 \cdot 10^{+195}:\\
\;\;\;\;\left(0.011111111111111112 \cdot angle\right) \cdot \left(\left(\left|b\right| + \left|a\right|\right) \cdot \left(\left(\left|b\right| - \left|a\right|\right) \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left|a\right| + \left|b\right|\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\left|b\right| \cdot \pi\right)\right)\right)\\
\end{array}
if b < 3.8e195Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
if 3.8e195 < b Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6439.9%
Applied rewrites39.9%
(FPCore (a b angle)
:precision binary64
(if (<= (fabs b) 3.8e+195)
(*
0.011111111111111112
(* (* angle (* (- (fabs b) (fabs a)) (+ (fabs b) (fabs a)))) PI))
(*
(+ (fabs a) (fabs b))
(* 0.011111111111111112 (* angle (* (fabs b) PI))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(b) <= 3.8e+195) {
tmp = 0.011111111111111112 * ((angle * ((fabs(b) - fabs(a)) * (fabs(b) + fabs(a)))) * ((double) M_PI));
} else {
tmp = (fabs(a) + fabs(b)) * (0.011111111111111112 * (angle * (fabs(b) * ((double) M_PI))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(b) <= 3.8e+195) {
tmp = 0.011111111111111112 * ((angle * ((Math.abs(b) - Math.abs(a)) * (Math.abs(b) + Math.abs(a)))) * Math.PI);
} else {
tmp = (Math.abs(a) + Math.abs(b)) * (0.011111111111111112 * (angle * (Math.abs(b) * Math.PI)));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(b) <= 3.8e+195: tmp = 0.011111111111111112 * ((angle * ((math.fabs(b) - math.fabs(a)) * (math.fabs(b) + math.fabs(a)))) * math.pi) else: tmp = (math.fabs(a) + math.fabs(b)) * (0.011111111111111112 * (angle * (math.fabs(b) * math.pi))) return tmp
function code(a, b, angle) tmp = 0.0 if (abs(b) <= 3.8e+195) tmp = Float64(0.011111111111111112 * Float64(Float64(angle * Float64(Float64(abs(b) - abs(a)) * Float64(abs(b) + abs(a)))) * pi)); else tmp = Float64(Float64(abs(a) + abs(b)) * Float64(0.011111111111111112 * Float64(angle * Float64(abs(b) * pi)))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(b) <= 3.8e+195) tmp = 0.011111111111111112 * ((angle * ((abs(b) - abs(a)) * (abs(b) + abs(a)))) * pi); else tmp = (abs(a) + abs(b)) * (0.011111111111111112 * (angle * (abs(b) * pi))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Abs[b], $MachinePrecision], 3.8e+195], N[(0.011111111111111112 * N[(N[(angle * N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;\left|b\right| \leq 3.8 \cdot 10^{+195}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle \cdot \left(\left(\left|b\right| - \left|a\right|\right) \cdot \left(\left|b\right| + \left|a\right|\right)\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left|a\right| + \left|b\right|\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\left|b\right| \cdot \pi\right)\right)\right)\\
\end{array}
if b < 3.8e195Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
if 3.8e195 < b Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6439.9%
Applied rewrites39.9%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* (fabs b) PI)))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 4e+108)
(* (+ (fabs a) (fabs b)) (* 0.011111111111111112 (* (fabs angle) t_0)))
(*
(* 0.011111111111111112 (fabs angle))
(* (+ (fabs b) (fabs a)) t_0))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) * ((double) M_PI);
double tmp;
if (fabs(angle) <= 4e+108) {
tmp = (fabs(a) + fabs(b)) * (0.011111111111111112 * (fabs(angle) * t_0));
} else {
tmp = (0.011111111111111112 * fabs(angle)) * ((fabs(b) + fabs(a)) * t_0);
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) * Math.PI;
double tmp;
if (Math.abs(angle) <= 4e+108) {
tmp = (Math.abs(a) + Math.abs(b)) * (0.011111111111111112 * (Math.abs(angle) * t_0));
} else {
tmp = (0.011111111111111112 * Math.abs(angle)) * ((Math.abs(b) + Math.abs(a)) * t_0);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) * math.pi tmp = 0 if math.fabs(angle) <= 4e+108: tmp = (math.fabs(a) + math.fabs(b)) * (0.011111111111111112 * (math.fabs(angle) * t_0)) else: tmp = (0.011111111111111112 * math.fabs(angle)) * ((math.fabs(b) + math.fabs(a)) * t_0) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) * pi) tmp = 0.0 if (abs(angle) <= 4e+108) tmp = Float64(Float64(abs(a) + abs(b)) * Float64(0.011111111111111112 * Float64(abs(angle) * t_0))); else tmp = Float64(Float64(0.011111111111111112 * abs(angle)) * Float64(Float64(abs(b) + abs(a)) * t_0)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) * pi; tmp = 0.0; if (abs(angle) <= 4e+108) tmp = (abs(a) + abs(b)) * (0.011111111111111112 * (abs(angle) * t_0)); else tmp = (0.011111111111111112 * abs(angle)) * ((abs(b) + abs(a)) * t_0); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 4e+108], N[(N[(N[Abs[a], $MachinePrecision] + N[Abs[b], $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.011111111111111112 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left|b\right| \cdot \pi\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 4 \cdot 10^{+108}:\\
\;\;\;\;\left(\left|a\right| + \left|b\right|\right) \cdot \left(0.011111111111111112 \cdot \left(\left|angle\right| \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left|angle\right|\right) \cdot \left(\left(\left|b\right| + \left|a\right|\right) \cdot t\_0\right)\\
\end{array}
\end{array}
if angle < 4.0000000000000001e108Initial program 53.4%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites67.0%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.6%
Applied rewrites41.6%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6439.9%
Applied rewrites39.9%
if 4.0000000000000001e108 < angle Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
Taylor expanded in a around 0
lower-*.f64N/A
lower-PI.f6437.3%
Applied rewrites37.3%
(FPCore (a b angle) :precision binary64 (* (* 0.011111111111111112 angle) (* (+ b (fabs a)) (* b PI))))
double code(double a, double b, double angle) {
return (0.011111111111111112 * angle) * ((b + fabs(a)) * (b * ((double) M_PI)));
}
public static double code(double a, double b, double angle) {
return (0.011111111111111112 * angle) * ((b + Math.abs(a)) * (b * Math.PI));
}
def code(a, b, angle): return (0.011111111111111112 * angle) * ((b + math.fabs(a)) * (b * math.pi))
function code(a, b, angle) return Float64(Float64(0.011111111111111112 * angle) * Float64(Float64(b + abs(a)) * Float64(b * pi))) end
function tmp = code(a, b, angle) tmp = (0.011111111111111112 * angle) * ((b + abs(a)) * (b * pi)); end
code[a_, b_, angle_] := N[(N[(0.011111111111111112 * angle), $MachinePrecision] * N[(N[(b + N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[(b * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\left(0.011111111111111112 \cdot angle\right) \cdot \left(\left(b + \left|a\right|\right) \cdot \left(b \cdot \pi\right)\right)
Initial program 53.4%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.5%
Applied rewrites50.5%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.5%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.4%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.4%
Applied rewrites54.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6454.4%
Applied rewrites54.4%
Taylor expanded in a around 0
lower-*.f64N/A
lower-PI.f6437.3%
Applied rewrites37.3%
herbie shell --seed 2025179
(FPCore (a b angle)
:name "ab-angle->ABCF B"
:precision binary64
(* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin (* PI (/ angle 180.0)))) (cos (* PI (/ angle 180.0)))))