
(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}
\\
\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}
\end{array}
Herbie found 20 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}
\\
\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}
\end{array}
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1.55e+106)
(*
(* (* (sin (* (* 0.005555555555555556 angle_m) PI)) (+ a_m b)) 2.0)
(* (- b a_m) (cos (* -0.005555555555555556 (* angle_m PI)))))
(*
(* (- b a_m) (+ a_m b))
(sin
(*
2.0
(*
(pow (cbrt PI) 2.0)
(* (cbrt PI) (* 0.005555555555555556 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.55e+106) {
tmp = ((sin(((0.005555555555555556 * angle_m) * ((double) M_PI))) * (a_m + b)) * 2.0) * ((b - a_m) * cos((-0.005555555555555556 * (angle_m * ((double) M_PI)))));
} else {
tmp = ((b - a_m) * (a_m + b)) * sin((2.0 * (pow(cbrt(((double) M_PI)), 2.0) * (cbrt(((double) M_PI)) * (0.005555555555555556 * angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.55e+106) {
tmp = ((Math.sin(((0.005555555555555556 * angle_m) * Math.PI)) * (a_m + b)) * 2.0) * ((b - a_m) * Math.cos((-0.005555555555555556 * (angle_m * Math.PI))));
} else {
tmp = ((b - a_m) * (a_m + b)) * Math.sin((2.0 * (Math.pow(Math.cbrt(Math.PI), 2.0) * (Math.cbrt(Math.PI) * (0.005555555555555556 * angle_m)))));
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 1.55e+106) tmp = Float64(Float64(Float64(sin(Float64(Float64(0.005555555555555556 * angle_m) * pi)) * Float64(a_m + b)) * 2.0) * Float64(Float64(b - a_m) * cos(Float64(-0.005555555555555556 * Float64(angle_m * pi))))); else tmp = Float64(Float64(Float64(b - a_m) * Float64(a_m + b)) * sin(Float64(2.0 * Float64((cbrt(pi) ^ 2.0) * Float64(cbrt(pi) * Float64(0.005555555555555556 * angle_m)))))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1.55e+106], N[(N[(N[(N[Sin[N[(N[(0.005555555555555556 * angle$95$m), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(-0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(2.0 * N[(N[Power[N[Power[Pi, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Power[Pi, 1/3], $MachinePrecision] * N[(0.005555555555555556 * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.55 \cdot 10^{+106}:\\
\;\;\;\;\left(\left(\sin \left(\left(0.005555555555555556 \cdot angle\_m\right) \cdot \pi\right) \cdot \left(a\_m + b\right)\right) \cdot 2\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(-0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right) \cdot \sin \left(2 \cdot \left({\left(\sqrt[3]{\pi}\right)}^{2} \cdot \left(\sqrt[3]{\pi} \cdot \left(0.005555555555555556 \cdot angle\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 1.55e106Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.6%
if 1.55e106 < angle Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
Applied rewrites58.1%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-PI.f64N/A
add-cube-cbrtN/A
metadata-evalN/A
mult-flipN/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-PI.f64N/A
pow1/3N/A
lift-PI.f64N/A
pow1/3N/A
pow-prod-upN/A
lower-pow.f64N/A
metadata-evalN/A
lower-*.f64N/A
lift-PI.f64N/A
lower-cbrt.f6457.8
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f6457.8
Applied rewrites57.8%
lift-pow.f64N/A
metadata-evalN/A
pow-cbrtN/A
lift-cbrt.f64N/A
lower-pow.f6457.8
Applied rewrites57.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= b 2.9e-111)
(* (* (sin (* 0.011111111111111112 (* angle_m PI))) (- b a_m)) (+ a_m b))
(if (<= b 8.4e+201)
(*
(* (* (sin (* (* 0.005555555555555556 angle_m) PI)) (+ a_m b)) 2.0)
(* (- b a_m) 1.0))
(* 0.011111111111111112 (* (* (* PI angle_m) (- b a_m)) (+ a_m b)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 2.9e-111) {
tmp = (sin((0.011111111111111112 * (angle_m * ((double) M_PI)))) * (b - a_m)) * (a_m + b);
} else if (b <= 8.4e+201) {
tmp = ((sin(((0.005555555555555556 * angle_m) * ((double) M_PI))) * (a_m + b)) * 2.0) * ((b - a_m) * 1.0);
} else {
tmp = 0.011111111111111112 * (((((double) M_PI) * angle_m) * (b - a_m)) * (a_m + b));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 2.9e-111) {
tmp = (Math.sin((0.011111111111111112 * (angle_m * Math.PI))) * (b - a_m)) * (a_m + b);
} else if (b <= 8.4e+201) {
tmp = ((Math.sin(((0.005555555555555556 * angle_m) * Math.PI)) * (a_m + b)) * 2.0) * ((b - a_m) * 1.0);
} else {
tmp = 0.011111111111111112 * (((Math.PI * angle_m) * (b - a_m)) * (a_m + b));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if b <= 2.9e-111: tmp = (math.sin((0.011111111111111112 * (angle_m * math.pi))) * (b - a_m)) * (a_m + b) elif b <= 8.4e+201: tmp = ((math.sin(((0.005555555555555556 * angle_m) * math.pi)) * (a_m + b)) * 2.0) * ((b - a_m) * 1.0) else: tmp = 0.011111111111111112 * (((math.pi * angle_m) * (b - a_m)) * (a_m + b)) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (b <= 2.9e-111) tmp = Float64(Float64(sin(Float64(0.011111111111111112 * Float64(angle_m * pi))) * Float64(b - a_m)) * Float64(a_m + b)); elseif (b <= 8.4e+201) tmp = Float64(Float64(Float64(sin(Float64(Float64(0.005555555555555556 * angle_m) * pi)) * Float64(a_m + b)) * 2.0) * Float64(Float64(b - a_m) * 1.0)); else tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(pi * angle_m) * Float64(b - a_m)) * Float64(a_m + b))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (b <= 2.9e-111) tmp = (sin((0.011111111111111112 * (angle_m * pi))) * (b - a_m)) * (a_m + b); elseif (b <= 8.4e+201) tmp = ((sin(((0.005555555555555556 * angle_m) * pi)) * (a_m + b)) * 2.0) * ((b - a_m) * 1.0); else tmp = 0.011111111111111112 * (((pi * angle_m) * (b - a_m)) * (a_m + b)); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b, 2.9e-111], N[(N[(N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 8.4e+201], N[(N[(N[(N[Sin[N[(N[(0.005555555555555556 * angle$95$m), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * 1.0), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b \leq 2.9 \cdot 10^{-111}:\\
\;\;\;\;\left(\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(a\_m + b\right)\\
\mathbf{elif}\;b \leq 8.4 \cdot 10^{+201}:\\
\;\;\;\;\left(\left(\sin \left(\left(0.005555555555555556 \cdot angle\_m\right) \cdot \pi\right) \cdot \left(a\_m + b\right)\right) \cdot 2\right) \cdot \left(\left(b - a\_m\right) \cdot 1\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(\pi \cdot angle\_m\right) \cdot \left(b - a\_m\right)\right) \cdot \left(a\_m + b\right)\right)\\
\end{array}
\end{array}
if b < 2.90000000000000002e-111Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.9%
if 2.90000000000000002e-111 < b < 8.3999999999999996e201Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.6%
Taylor expanded in angle around 0
Applied rewrites66.2%
if 8.3999999999999996e201 < b Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6462.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6462.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.8
Applied rewrites62.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 4.6e+16)
(* (* (sin (* 0.011111111111111112 (* angle_m PI))) (- b a_m)) (+ a_m b))
(if (<= angle_m 2.5e+211)
(* 0.011111111111111112 (* (* angle_m (fma b b (* (- a_m) a_m))) PI))
(*
(* (- b a_m) (+ a_m b))
(sin (* (* 0.005555555555555556 angle_m) (+ PI PI))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 4.6e+16) {
tmp = (sin((0.011111111111111112 * (angle_m * ((double) M_PI)))) * (b - a_m)) * (a_m + b);
} else if (angle_m <= 2.5e+211) {
tmp = 0.011111111111111112 * ((angle_m * fma(b, b, (-a_m * a_m))) * ((double) M_PI));
} else {
tmp = ((b - a_m) * (a_m + b)) * sin(((0.005555555555555556 * angle_m) * (((double) M_PI) + ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 4.6e+16) tmp = Float64(Float64(sin(Float64(0.011111111111111112 * Float64(angle_m * pi))) * Float64(b - a_m)) * Float64(a_m + b)); elseif (angle_m <= 2.5e+211) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * fma(b, b, Float64(Float64(-a_m) * a_m))) * pi)); else tmp = Float64(Float64(Float64(b - a_m) * Float64(a_m + b)) * sin(Float64(Float64(0.005555555555555556 * angle_m) * Float64(pi + pi)))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 4.6e+16], N[(N[(N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 2.5e+211], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * b + N[((-a$95$m) * a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(0.005555555555555556 * angle$95$m), $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 4.6 \cdot 10^{+16}:\\
\;\;\;\;\left(\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(a\_m + b\right)\\
\mathbf{elif}\;angle\_m \leq 2.5 \cdot 10^{+211}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \mathsf{fma}\left(b, b, \left(-a\_m\right) \cdot a\_m\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right) \cdot \sin \left(\left(0.005555555555555556 \cdot angle\_m\right) \cdot \left(\pi + \pi\right)\right)\\
\end{array}
\end{array}
if angle < 4.6e16Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.9%
if 4.6e16 < angle < 2.4999999999999998e211Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
unpow2N/A
unpow2N/A
fp-cancel-sub-sign-invN/A
unpow2N/A
distribute-lft-neg-inN/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6453.2
Applied rewrites53.2%
if 2.4999999999999998e211 < angle Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
Applied rewrites58.1%
lift-*.f64N/A
count-2-revN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
metadata-evalN/A
mult-flipN/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
metadata-evalN/A
mult-flipN/A
lift-/.f64N/A
distribute-rgt-outN/A
lower-*.f64N/A
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lower-+.f6458.1
Applied rewrites58.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 8.2e+204)
(*
(*
(- b a_m)
(* (+ a_m b) (* (sin (* (* PI angle_m) 0.005555555555555556)) 2.0)))
1.0)
(*
(* (- b a_m) (+ a_m b))
(sin (* 2.0 (* (* 0.005555555555555556 PI) angle_m)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 8.2e+204) {
tmp = ((b - a_m) * ((a_m + b) * (sin(((((double) M_PI) * angle_m) * 0.005555555555555556)) * 2.0))) * 1.0;
} else {
tmp = ((b - a_m) * (a_m + b)) * sin((2.0 * ((0.005555555555555556 * ((double) M_PI)) * angle_m)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 8.2e+204) {
tmp = ((b - a_m) * ((a_m + b) * (Math.sin(((Math.PI * angle_m) * 0.005555555555555556)) * 2.0))) * 1.0;
} else {
tmp = ((b - a_m) * (a_m + b)) * Math.sin((2.0 * ((0.005555555555555556 * Math.PI) * angle_m)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 8.2e+204: tmp = ((b - a_m) * ((a_m + b) * (math.sin(((math.pi * angle_m) * 0.005555555555555556)) * 2.0))) * 1.0 else: tmp = ((b - a_m) * (a_m + b)) * math.sin((2.0 * ((0.005555555555555556 * math.pi) * angle_m))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 8.2e+204) tmp = Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * Float64(sin(Float64(Float64(pi * angle_m) * 0.005555555555555556)) * 2.0))) * 1.0); else tmp = Float64(Float64(Float64(b - a_m) * Float64(a_m + b)) * sin(Float64(2.0 * Float64(Float64(0.005555555555555556 * pi) * angle_m)))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 8.2e+204) tmp = ((b - a_m) * ((a_m + b) * (sin(((pi * angle_m) * 0.005555555555555556)) * 2.0))) * 1.0; else tmp = ((b - a_m) * (a_m + b)) * sin((2.0 * ((0.005555555555555556 * pi) * angle_m))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 8.2e+204], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * N[(N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(2.0 * N[(N[(0.005555555555555556 * Pi), $MachinePrecision] * angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 8.2 \cdot 10^{+204}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot \left(\sin \left(\left(\pi \cdot angle\_m\right) \cdot 0.005555555555555556\right) \cdot 2\right)\right)\right) \cdot 1\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right) \cdot \sin \left(2 \cdot \left(\left(0.005555555555555556 \cdot \pi\right) \cdot angle\_m\right)\right)\\
\end{array}
\end{array}
if angle < 8.19999999999999949e204Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Taylor expanded in angle around 0
Applied rewrites66.2%
if 8.19999999999999949e204 < angle Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
Applied rewrites58.1%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lower-*.f6458.1
Applied rewrites58.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 4.6e+16)
(* (* (sin (* 0.011111111111111112 (* angle_m PI))) (- b a_m)) (+ a_m b))
(if (<= angle_m 2.4e+211)
(* 0.011111111111111112 (* (* angle_m (fma b b (* (- a_m) a_m))) PI))
(*
(* (- b a_m) (+ a_m b))
(sin (* (* angle_m PI) 0.011111111111111112)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 4.6e+16) {
tmp = (sin((0.011111111111111112 * (angle_m * ((double) M_PI)))) * (b - a_m)) * (a_m + b);
} else if (angle_m <= 2.4e+211) {
tmp = 0.011111111111111112 * ((angle_m * fma(b, b, (-a_m * a_m))) * ((double) M_PI));
} else {
tmp = ((b - a_m) * (a_m + b)) * sin(((angle_m * ((double) M_PI)) * 0.011111111111111112));
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 4.6e+16) tmp = Float64(Float64(sin(Float64(0.011111111111111112 * Float64(angle_m * pi))) * Float64(b - a_m)) * Float64(a_m + b)); elseif (angle_m <= 2.4e+211) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * fma(b, b, Float64(Float64(-a_m) * a_m))) * pi)); else tmp = Float64(Float64(Float64(b - a_m) * Float64(a_m + b)) * sin(Float64(Float64(angle_m * pi) * 0.011111111111111112))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 4.6e+16], N[(N[(N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 2.4e+211], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * b + N[((-a$95$m) * a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 4.6 \cdot 10^{+16}:\\
\;\;\;\;\left(\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(a\_m + b\right)\\
\mathbf{elif}\;angle\_m \leq 2.4 \cdot 10^{+211}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \mathsf{fma}\left(b, b, \left(-a\_m\right) \cdot a\_m\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right) \cdot \sin \left(\left(angle\_m \cdot \pi\right) \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 4.6e16Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.9%
if 4.6e16 < angle < 2.40000000000000018e211Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
unpow2N/A
unpow2N/A
fp-cancel-sub-sign-invN/A
unpow2N/A
distribute-lft-neg-inN/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6453.2
Applied rewrites53.2%
if 2.40000000000000018e211 < angle Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
Applied rewrites58.1%
lift-*.f64N/A
count-2-revN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-lft-outN/A
metadata-evalN/A
lower-*.f6458.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6458.2
Applied rewrites58.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0
(*
(* (sin (* 0.011111111111111112 (* angle_m PI))) (- b a_m))
(+ a_m b))))
(*
angle_s
(if (<= angle_m 4.6e+16)
t_0
(if (<= angle_m 2.4e+211)
(* 0.011111111111111112 (* (* angle_m (fma b b (* (- a_m) a_m))) PI))
t_0)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = (sin((0.011111111111111112 * (angle_m * ((double) M_PI)))) * (b - a_m)) * (a_m + b);
double tmp;
if (angle_m <= 4.6e+16) {
tmp = t_0;
} else if (angle_m <= 2.4e+211) {
tmp = 0.011111111111111112 * ((angle_m * fma(b, b, (-a_m * a_m))) * ((double) M_PI));
} else {
tmp = t_0;
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(Float64(sin(Float64(0.011111111111111112 * Float64(angle_m * pi))) * Float64(b - a_m)) * Float64(a_m + b)) tmp = 0.0 if (angle_m <= 4.6e+16) tmp = t_0; elseif (angle_m <= 2.4e+211) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * fma(b, b, Float64(Float64(-a_m) * a_m))) * pi)); else tmp = t_0; end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(N[(N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 4.6e+16], t$95$0, If[LessEqual[angle$95$m, 2.4e+211], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * b + N[((-a$95$m) * a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], t$95$0]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \left(\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(a\_m + b\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 4.6 \cdot 10^{+16}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;angle\_m \leq 2.4 \cdot 10^{+211}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \mathsf{fma}\left(b, b, \left(-a\_m\right) \cdot a\_m\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
\end{array}
if angle < 4.6e16 or 2.40000000000000018e211 < angle Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.9%
if 4.6e16 < angle < 2.40000000000000018e211Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
unpow2N/A
unpow2N/A
fp-cancel-sub-sign-invN/A
unpow2N/A
distribute-lft-neg-inN/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6453.2
Applied rewrites53.2%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* (* (sin (* (* 0.005555555555555556 angle_m) PI)) (+ a_m b)) 2.0) (* (- b a_m) (cos (* (* -0.005555555555555556 PI) angle_m))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((sin(((0.005555555555555556 * angle_m) * ((double) M_PI))) * (a_m + b)) * 2.0) * ((b - a_m) * cos(((-0.005555555555555556 * ((double) M_PI)) * angle_m))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((Math.sin(((0.005555555555555556 * angle_m) * Math.PI)) * (a_m + b)) * 2.0) * ((b - a_m) * Math.cos(((-0.005555555555555556 * Math.PI) * angle_m))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (((math.sin(((0.005555555555555556 * angle_m) * math.pi)) * (a_m + b)) * 2.0) * ((b - a_m) * math.cos(((-0.005555555555555556 * math.pi) * angle_m))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(Float64(sin(Float64(Float64(0.005555555555555556 * angle_m) * pi)) * Float64(a_m + b)) * 2.0) * Float64(Float64(b - a_m) * cos(Float64(Float64(-0.005555555555555556 * pi) * angle_m))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (((sin(((0.005555555555555556 * angle_m) * pi)) * (a_m + b)) * 2.0) * ((b - a_m) * cos(((-0.005555555555555556 * pi) * angle_m)))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(N[(N[Sin[N[(N[(0.005555555555555556 * angle$95$m), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[(-0.005555555555555556 * Pi), $MachinePrecision] * angle$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(\left(\sin \left(\left(0.005555555555555556 \cdot angle\_m\right) \cdot \pi\right) \cdot \left(a\_m + b\right)\right) \cdot 2\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(\left(-0.005555555555555556 \cdot \pi\right) \cdot angle\_m\right)\right)\right)
\end{array}
Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6467.9
Applied rewrites67.9%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* (* (sin (* (* 0.005555555555555556 angle_m) PI)) (+ a_m b)) 2.0) (* (- b a_m) (cos (* -0.005555555555555556 (* angle_m PI)))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((sin(((0.005555555555555556 * angle_m) * ((double) M_PI))) * (a_m + b)) * 2.0) * ((b - a_m) * cos((-0.005555555555555556 * (angle_m * ((double) M_PI))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((Math.sin(((0.005555555555555556 * angle_m) * Math.PI)) * (a_m + b)) * 2.0) * ((b - a_m) * Math.cos((-0.005555555555555556 * (angle_m * Math.PI)))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (((math.sin(((0.005555555555555556 * angle_m) * math.pi)) * (a_m + b)) * 2.0) * ((b - a_m) * math.cos((-0.005555555555555556 * (angle_m * math.pi)))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(Float64(sin(Float64(Float64(0.005555555555555556 * angle_m) * pi)) * Float64(a_m + b)) * 2.0) * Float64(Float64(b - a_m) * cos(Float64(-0.005555555555555556 * Float64(angle_m * pi)))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (((sin(((0.005555555555555556 * angle_m) * pi)) * (a_m + b)) * 2.0) * ((b - a_m) * cos((-0.005555555555555556 * (angle_m * pi))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(N[(N[Sin[N[(N[(0.005555555555555556 * angle$95$m), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(-0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(\left(\sin \left(\left(0.005555555555555556 \cdot angle\_m\right) \cdot \pi\right) \cdot \left(a\_m + b\right)\right) \cdot 2\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(-0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)
\end{array}
Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.9
lift-*.f64N/A
*-commutativeN/A
Applied rewrites67.6%
Applied rewrites67.6%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (- b a_m) (* (sin (* (* angle_m 0.005555555555555556) (+ PI PI))) (+ b a_m)))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b - a_m) * (sin(((angle_m * 0.005555555555555556) * (((double) M_PI) + ((double) M_PI)))) * (b + a_m)));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b - a_m) * (Math.sin(((angle_m * 0.005555555555555556) * (Math.PI + Math.PI))) * (b + a_m)));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b - a_m) * (math.sin(((angle_m * 0.005555555555555556) * (math.pi + math.pi))) * (b + a_m)))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b - a_m) * Float64(sin(Float64(Float64(angle_m * 0.005555555555555556) * Float64(pi + pi))) * Float64(b + a_m)))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((b - a_m) * (sin(((angle_m * 0.005555555555555556) * (pi + pi))) * (b + a_m))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b - a$95$m), $MachinePrecision] * N[(N[Sin[N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b - a\_m\right) \cdot \left(\sin \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot \left(\pi + \pi\right)\right) \cdot \left(b + a\_m\right)\right)\right)
\end{array}
Initial program 54.1%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-*.f6457.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6457.9
lift-/.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval58.2
Applied rewrites58.2%
Applied rewrites58.1%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-PI.f64N/A
add-cube-cbrtN/A
metadata-evalN/A
mult-flipN/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-PI.f64N/A
pow1/3N/A
lift-PI.f64N/A
pow1/3N/A
pow-prod-upN/A
lower-pow.f64N/A
metadata-evalN/A
lower-*.f64N/A
lift-PI.f64N/A
lower-cbrt.f6457.8
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f6457.8
Applied rewrites57.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.5
Applied rewrites67.9%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 9e-17)
(* (* (* angle_m (+ a_m b)) (- b a_m)) (* PI 0.011111111111111112))
(* 0.011111111111111112 (* (* angle_m (fma b b (* (- a_m) a_m))) PI)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 9e-17) {
tmp = ((angle_m * (a_m + b)) * (b - a_m)) * (((double) M_PI) * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * ((angle_m * fma(b, b, (-a_m * a_m))) * ((double) M_PI));
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 9e-17) tmp = Float64(Float64(Float64(angle_m * Float64(a_m + b)) * Float64(b - a_m)) * Float64(pi * 0.011111111111111112)); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * fma(b, b, Float64(Float64(-a_m) * a_m))) * pi)); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 9e-17], N[(N[(N[(angle$95$m * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * b + N[((-a$95$m) * a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 9 \cdot 10^{-17}:\\
\;\;\;\;\left(\left(angle\_m \cdot \left(a\_m + b\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \mathsf{fma}\left(b, b, \left(-a\_m\right) \cdot a\_m\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 8.99999999999999957e-17Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
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
lower-*.f6462.9
Applied rewrites62.9%
if 8.99999999999999957e-17 < angle Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
unpow2N/A
unpow2N/A
fp-cancel-sub-sign-invN/A
unpow2N/A
distribute-lft-neg-inN/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6453.2
Applied rewrites53.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 6.8e+59)
(* (* (* angle_m (+ a_m b)) (- b a_m)) (* PI 0.011111111111111112))
(* 0.011111111111111112 (* (* angle_m (* (* -1.0 a_m) (+ a_m b))) PI)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 6.8e+59) {
tmp = ((angle_m * (a_m + b)) * (b - a_m)) * (((double) M_PI) * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * ((angle_m * ((-1.0 * a_m) * (a_m + b))) * ((double) M_PI));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 6.8e+59) {
tmp = ((angle_m * (a_m + b)) * (b - a_m)) * (Math.PI * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * ((angle_m * ((-1.0 * a_m) * (a_m + b))) * Math.PI);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 6.8e+59: tmp = ((angle_m * (a_m + b)) * (b - a_m)) * (math.pi * 0.011111111111111112) else: tmp = 0.011111111111111112 * ((angle_m * ((-1.0 * a_m) * (a_m + b))) * math.pi) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 6.8e+59) tmp = Float64(Float64(Float64(angle_m * Float64(a_m + b)) * Float64(b - a_m)) * Float64(pi * 0.011111111111111112)); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * Float64(Float64(-1.0 * a_m) * Float64(a_m + b))) * pi)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 6.8e+59) tmp = ((angle_m * (a_m + b)) * (b - a_m)) * (pi * 0.011111111111111112); else tmp = 0.011111111111111112 * ((angle_m * ((-1.0 * a_m) * (a_m + b))) * pi); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 6.8e+59], N[(N[(N[(angle$95$m * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(N[(-1.0 * a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 6.8 \cdot 10^{+59}:\\
\;\;\;\;\left(\left(angle\_m \cdot \left(a\_m + b\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \left(\left(-1 \cdot a\_m\right) \cdot \left(a\_m + b\right)\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 6.80000000000000012e59Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
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
lower-*.f6462.9
Applied rewrites62.9%
if 6.80000000000000012e59 < angle Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around inf
lower-*.f6437.3
Applied rewrites37.3%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* (* angle_m (+ a_m b)) (- b a_m)) (* PI 0.011111111111111112))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((angle_m * (a_m + b)) * (b - a_m)) * (((double) M_PI) * 0.011111111111111112));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((angle_m * (a_m + b)) * (b - a_m)) * (Math.PI * 0.011111111111111112));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (((angle_m * (a_m + b)) * (b - a_m)) * (math.pi * 0.011111111111111112))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(Float64(angle_m * Float64(a_m + b)) * Float64(b - a_m)) * Float64(pi * 0.011111111111111112))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (((angle_m * (a_m + b)) * (b - a_m)) * (pi * 0.011111111111111112)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(N[(angle$95$m * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(\left(angle\_m \cdot \left(a\_m + b\right)\right) \cdot \left(b - a\_m\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
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
lower-*.f6462.9
Applied rewrites62.9%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* (* angle_m (- b a_m)) (* (+ a_m b) PI)))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b - a_m)) * ((a_m + b) * ((double) M_PI))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b - a_m)) * ((a_m + b) * Math.PI)));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (0.011111111111111112 * ((angle_m * (b - a_m)) * ((a_m + b) * math.pi)))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(Float64(angle_m * Float64(b - a_m)) * Float64(Float64(a_m + b) * pi)))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (0.011111111111111112 * ((angle_m * (b - a_m)) * ((a_m + b) * pi))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(\left(angle\_m \cdot \left(b - a\_m\right)\right) \cdot \left(\left(a\_m + b\right) \cdot \pi\right)\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6462.8
Applied rewrites62.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (* 2.0 (- (pow b 2.0) (pow a_m 2.0))) 1e+60)
(* 0.011111111111111112 (* (* angle_m (* (- b a_m) (+ a_m b))) PI))
(* (* (* angle_m (+ b a_m)) b) (* PI 0.011111111111111112)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((2.0 * (pow(b, 2.0) - pow(a_m, 2.0))) <= 1e+60) {
tmp = 0.011111111111111112 * ((angle_m * ((b - a_m) * (a_m + b))) * ((double) M_PI));
} else {
tmp = ((angle_m * (b + a_m)) * b) * (((double) M_PI) * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((2.0 * (Math.pow(b, 2.0) - Math.pow(a_m, 2.0))) <= 1e+60) {
tmp = 0.011111111111111112 * ((angle_m * ((b - a_m) * (a_m + b))) * Math.PI);
} else {
tmp = ((angle_m * (b + a_m)) * b) * (Math.PI * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if (2.0 * (math.pow(b, 2.0) - math.pow(a_m, 2.0))) <= 1e+60: tmp = 0.011111111111111112 * ((angle_m * ((b - a_m) * (a_m + b))) * math.pi) else: tmp = ((angle_m * (b + a_m)) * b) * (math.pi * 0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (Float64(2.0 * Float64((b ^ 2.0) - (a_m ^ 2.0))) <= 1e+60) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * Float64(Float64(b - a_m) * Float64(a_m + b))) * pi)); else tmp = Float64(Float64(Float64(angle_m * Float64(b + a_m)) * b) * Float64(pi * 0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((2.0 * ((b ^ 2.0) - (a_m ^ 2.0))) <= 1e+60) tmp = 0.011111111111111112 * ((angle_m * ((b - a_m) * (a_m + b))) * pi); else tmp = ((angle_m * (b + a_m)) * b) * (pi * 0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+60], N[(0.011111111111111112 * N[(N[(angle$95$m * N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(angle$95$m * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;2 \cdot \left({b}^{2} - {a\_m}^{2}\right) \leq 10^{+60}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot \left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(angle\_m \cdot \left(b + a\_m\right)\right) \cdot b\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) < 9.9999999999999995e59Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
if 9.9999999999999995e59 < (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
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
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-*.f6442.4
Applied rewrites42.4%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* (* angle_m (+ b a_m)) b) (* PI 0.011111111111111112))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((angle_m * (b + a_m)) * b) * (((double) M_PI) * 0.011111111111111112));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((angle_m * (b + a_m)) * b) * (Math.PI * 0.011111111111111112));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (((angle_m * (b + a_m)) * b) * (math.pi * 0.011111111111111112))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(Float64(angle_m * Float64(b + a_m)) * b) * Float64(pi * 0.011111111111111112))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (((angle_m * (b + a_m)) * b) * (pi * 0.011111111111111112)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(N[(angle$95$m * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(\left(angle\_m \cdot \left(b + a\_m\right)\right) \cdot b\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
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
lift-+.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-*.f6442.4
Applied rewrites42.4%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* (* 0.011111111111111112 (* b angle_m)) (+ b a_m)) PI)))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((0.011111111111111112 * (b * angle_m)) * (b + a_m)) * ((double) M_PI));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (((0.011111111111111112 * (b * angle_m)) * (b + a_m)) * Math.PI);
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (((0.011111111111111112 * (b * angle_m)) * (b + a_m)) * math.pi)
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(Float64(0.011111111111111112 * Float64(b * angle_m)) * Float64(b + a_m)) * pi)) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (((0.011111111111111112 * (b * angle_m)) * (b + a_m)) * pi); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(N[(0.011111111111111112 * N[(b * angle$95$m), $MachinePrecision]), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(\left(0.011111111111111112 \cdot \left(b \cdot angle\_m\right)\right) \cdot \left(b + a\_m\right)\right) \cdot \pi\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
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
*-commutativeN/A
lower-*.f6441.0
lift-+.f64N/A
+-commutativeN/A
lift-+.f6441.0
Applied rewrites41.0%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* angle_m (* (* b (* (+ b a_m) PI)) 0.011111111111111112))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (angle_m * ((b * ((b + a_m) * ((double) M_PI))) * 0.011111111111111112));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (angle_m * ((b * ((b + a_m) * Math.PI)) * 0.011111111111111112));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (angle_m * ((b * ((b + a_m) * math.pi)) * 0.011111111111111112))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(angle_m * Float64(Float64(b * Float64(Float64(b + a_m) * pi)) * 0.011111111111111112))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (angle_m * ((b * ((b + a_m) * pi)) * 0.011111111111111112)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(angle$95$m * N[(N[(b * N[(N[(b + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(angle\_m \cdot \left(\left(b \cdot \left(\left(b + a\_m\right) \cdot \pi\right)\right) \cdot 0.011111111111111112\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6438.2
lift-+.f64N/A
+-commutativeN/A
lift-+.f6438.2
Applied rewrites38.2%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* (* PI angle_m) (* b (+ b a_m))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((((double) M_PI) * angle_m) * (b * (b + a_m))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((Math.PI * angle_m) * (b * (b + a_m))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (0.011111111111111112 * ((math.pi * angle_m) * (b * (b + a_m))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(Float64(pi * angle_m) * Float64(b * Float64(b + a_m))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (0.011111111111111112 * ((pi * angle_m) * (b * (b + a_m)))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(b * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(\left(\pi \cdot angle\_m\right) \cdot \left(b \cdot \left(b + a\_m\right)\right)\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6438.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6438.2
lift-+.f64N/A
+-commutativeN/A
lift-+.f6438.2
Applied rewrites38.2%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* (* angle_m (* b (+ a_m b))) PI))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b * (a_m + b))) * ((double) M_PI)));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b * (a_m + b))) * Math.PI));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (0.011111111111111112 * ((angle_m * (b * (a_m + b))) * math.pi))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(Float64(angle_m * Float64(b * Float64(a_m + b))) * pi))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (0.011111111111111112 * ((angle_m * (b * (a_m + b))) * pi)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(\left(angle\_m \cdot \left(b \cdot \left(a\_m + b\right)\right)\right) \cdot \pi\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* (* angle_m (* b b)) PI))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b * b)) * ((double) M_PI)));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * ((angle_m * (b * b)) * Math.PI));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (0.011111111111111112 * ((angle_m * (b * b)) * math.pi))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(Float64(angle_m * Float64(b * b)) * pi))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (0.011111111111111112 * ((angle_m * (b * b)) * pi)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(N[(angle$95$m * N[(b * b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(\left(angle\_m \cdot \left(b \cdot b\right)\right) \cdot \pi\right)\right)
\end{array}
Initial program 54.1%
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.9
Applied rewrites50.9%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.9
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.9
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites38.2%
Taylor expanded in a around 0
Applied rewrites36.3%
herbie shell --seed 2025142
(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)))))