
(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}
Sampling outcomes in binary64 precision:
Herbie found 13 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}
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (sin (* 0.005555555555555556 (* angle_m PI))))
(t_1 (cos (* (/ angle_m 180.0) PI))))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+51)
(* (fma b (* 2.0 (* b t_0)) (* -2.0 (* a (* t_0 a)))) t_1)
(if (<= (/ angle_m 180.0) 1e+153)
(* t_1 (* (* (+ b a) (- a b)) (* 2.0 t_0)))
(*
(* t_0 (* 2.0 (* (+ b a) (- b a))))
(pow (cbrt (cos (* PI (* angle_m 0.005555555555555556)))) 3.0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = sin((0.005555555555555556 * (angle_m * ((double) M_PI))));
double t_1 = cos(((angle_m / 180.0) * ((double) M_PI)));
double tmp;
if ((angle_m / 180.0) <= 2e+51) {
tmp = fma(b, (2.0 * (b * t_0)), (-2.0 * (a * (t_0 * a)))) * t_1;
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = t_1 * (((b + a) * (a - b)) * (2.0 * t_0));
} else {
tmp = (t_0 * (2.0 * ((b + a) * (b - a)))) * pow(cbrt(cos((((double) M_PI) * (angle_m * 0.005555555555555556)))), 3.0);
}
return angle_s * tmp;
}
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = sin(Float64(0.005555555555555556 * Float64(angle_m * pi))) t_1 = cos(Float64(Float64(angle_m / 180.0) * pi)) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+51) tmp = Float64(fma(b, Float64(2.0 * Float64(b * t_0)), Float64(-2.0 * Float64(a * Float64(t_0 * a)))) * t_1); elseif (Float64(angle_m / 180.0) <= 1e+153) tmp = Float64(t_1 * Float64(Float64(Float64(b + a) * Float64(a - b)) * Float64(2.0 * t_0))); else tmp = Float64(Float64(t_0 * Float64(2.0 * Float64(Float64(b + a) * Float64(b - a)))) * (cbrt(cos(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 3.0)); end return Float64(angle_s * tmp) end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[Sin[N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+51], N[(N[(b * N[(2.0 * N[(b * t$95$0), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(a * N[(t$95$0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+153], N[(t$95$1 * N[(N[(N[(b + a), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision] * N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$0 * N[(2.0 * N[(N[(b + a), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[N[Cos[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \sin \left(0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\\
t_1 := \cos \left(\frac{angle\_m}{180} \cdot \pi\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+51}:\\
\;\;\;\;\mathsf{fma}\left(b, 2 \cdot \left(b \cdot t\_0\right), -2 \cdot \left(a \cdot \left(t\_0 \cdot a\right)\right)\right) \cdot t\_1\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 10^{+153}:\\
\;\;\;\;t\_1 \cdot \left(\left(\left(b + a\right) \cdot \left(a - b\right)\right) \cdot \left(2 \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t\_0 \cdot \left(2 \cdot \left(\left(b + a\right) \cdot \left(b - a\right)\right)\right)\right) \cdot {\left(\sqrt[3]{\cos \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)}\right)}^{3}\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2e51Initial program 55.1%
unpow255.1%
unpow255.1%
difference-of-squares57.8%
Applied egg-rr57.8%
Taylor expanded in b around 0 63.1%
+-commutative63.1%
fma-define64.6%
distribute-lft-out64.6%
*-commutative64.6%
distribute-rgt1-in64.6%
metadata-eval64.6%
mul0-lft64.6%
distribute-lft-out64.6%
+-rgt-identity64.6%
Simplified64.6%
*-commutative64.6%
associate-*r*63.3%
*-commutative63.3%
metadata-eval63.3%
div-inv62.6%
*-commutative62.6%
unpow262.6%
associate-*r*70.7%
*-commutative70.7%
div-inv71.3%
metadata-eval71.3%
*-commutative71.3%
associate-*r*72.6%
Applied egg-rr72.6%
if 2e51 < (/.f64 angle #s(literal 180 binary64)) < 1e153Initial program 43.4%
Taylor expanded in b around 0 23.5%
Simplified49.9%
unpow249.9%
unpow249.9%
difference-of-squares49.9%
Applied egg-rr49.9%
if 1e153 < (/.f64 angle #s(literal 180 binary64)) Initial program 39.5%
unpow239.5%
unpow239.5%
difference-of-squares42.3%
Applied egg-rr42.3%
div-inv40.1%
metadata-eval40.1%
add-cube-cbrt40.1%
pow340.1%
Applied egg-rr40.1%
Taylor expanded in angle around inf 47.6%
Final simplification67.4%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (* 0.005555555555555556 (* angle_m PI))) (t_1 (sin t_0)))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+64)
(* (fma b (* 2.0 (* b t_1)) (* -2.0 (* a (* t_1 a)))) (cos t_0))
(if (<= (/ angle_m 180.0) 1e+153)
(* (cos (* (/ angle_m 180.0) PI)) (* (* (+ b a) (- a b)) (* 2.0 t_1)))
(*
(* t_1 (* 2.0 (* (+ b a) (- b a))))
(pow (cbrt (cos (* PI (* angle_m 0.005555555555555556)))) 3.0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = 0.005555555555555556 * (angle_m * ((double) M_PI));
double t_1 = sin(t_0);
double tmp;
if ((angle_m / 180.0) <= 2e+64) {
tmp = fma(b, (2.0 * (b * t_1)), (-2.0 * (a * (t_1 * a)))) * cos(t_0);
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = cos(((angle_m / 180.0) * ((double) M_PI))) * (((b + a) * (a - b)) * (2.0 * t_1));
} else {
tmp = (t_1 * (2.0 * ((b + a) * (b - a)))) * pow(cbrt(cos((((double) M_PI) * (angle_m * 0.005555555555555556)))), 3.0);
}
return angle_s * tmp;
}
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = Float64(0.005555555555555556 * Float64(angle_m * pi)) t_1 = sin(t_0) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+64) tmp = Float64(fma(b, Float64(2.0 * Float64(b * t_1)), Float64(-2.0 * Float64(a * Float64(t_1 * a)))) * cos(t_0)); elseif (Float64(angle_m / 180.0) <= 1e+153) tmp = Float64(cos(Float64(Float64(angle_m / 180.0) * pi)) * Float64(Float64(Float64(b + a) * Float64(a - b)) * Float64(2.0 * t_1))); else tmp = Float64(Float64(t_1 * Float64(2.0 * Float64(Float64(b + a) * Float64(b - a)))) * (cbrt(cos(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 3.0)); end return Float64(angle_s * tmp) end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[t$95$0], $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+64], N[(N[(b * N[(2.0 * N[(b * t$95$1), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(a * N[(t$95$1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+153], N[(N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(b + a), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision] * N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$1 * N[(2.0 * N[(N[(b + a), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[N[Cos[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := 0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\\
t_1 := \sin t\_0\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(b, 2 \cdot \left(b \cdot t\_1\right), -2 \cdot \left(a \cdot \left(t\_1 \cdot a\right)\right)\right) \cdot \cos t\_0\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 10^{+153}:\\
\;\;\;\;\cos \left(\frac{angle\_m}{180} \cdot \pi\right) \cdot \left(\left(\left(b + a\right) \cdot \left(a - b\right)\right) \cdot \left(2 \cdot t\_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t\_1 \cdot \left(2 \cdot \left(\left(b + a\right) \cdot \left(b - a\right)\right)\right)\right) \cdot {\left(\sqrt[3]{\cos \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)}\right)}^{3}\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000004e64Initial program 55.0%
unpow255.0%
unpow255.0%
difference-of-squares57.6%
Applied egg-rr57.6%
Taylor expanded in b around 0 62.7%
+-commutative62.7%
fma-define64.2%
distribute-lft-out64.2%
*-commutative64.2%
distribute-rgt1-in64.2%
metadata-eval64.2%
mul0-lft64.2%
distribute-lft-out64.2%
+-rgt-identity64.2%
Simplified64.2%
*-commutative64.2%
associate-*r*63.0%
*-commutative63.0%
metadata-eval63.0%
div-inv62.4%
*-commutative62.4%
unpow262.4%
associate-*r*70.3%
*-commutative70.3%
div-inv71.0%
metadata-eval71.0%
*-commutative71.0%
associate-*r*72.2%
Applied egg-rr72.2%
Taylor expanded in angle around inf 71.2%
if 2.00000000000000004e64 < (/.f64 angle #s(literal 180 binary64)) < 1e153Initial program 42.9%
Taylor expanded in b around 0 20.4%
Simplified51.7%
unpow251.7%
unpow251.7%
difference-of-squares51.7%
Applied egg-rr51.7%
if 1e153 < (/.f64 angle #s(literal 180 binary64)) Initial program 39.5%
unpow239.5%
unpow239.5%
difference-of-squares42.3%
Applied egg-rr42.3%
div-inv40.1%
metadata-eval40.1%
add-cube-cbrt40.1%
pow340.1%
Applied egg-rr40.1%
Taylor expanded in angle around inf 47.6%
Final simplification66.7%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (sin (* 0.005555555555555556 (* angle_m PI)))))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+51)
(* (- a b) (* (* angle_m -0.011111111111111112) (* PI (+ b a))))
(if (<= (/ angle_m 180.0) 1e+153)
(* (cos (* (/ angle_m 180.0) PI)) (* (* (+ b a) (- a b)) (* 2.0 t_0)))
(*
(* t_0 (* 2.0 (* (+ b a) (- b a))))
(pow (cbrt (cos (* PI (* angle_m 0.005555555555555556)))) 3.0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = sin((0.005555555555555556 * (angle_m * ((double) M_PI))));
double tmp;
if ((angle_m / 180.0) <= 2e+51) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (((double) M_PI) * (b + a)));
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = cos(((angle_m / 180.0) * ((double) M_PI))) * (((b + a) * (a - b)) * (2.0 * t_0));
} else {
tmp = (t_0 * (2.0 * ((b + a) * (b - a)))) * pow(cbrt(cos((((double) M_PI) * (angle_m * 0.005555555555555556)))), 3.0);
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double t_0 = Math.sin((0.005555555555555556 * (angle_m * Math.PI)));
double tmp;
if ((angle_m / 180.0) <= 2e+51) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (Math.PI * (b + a)));
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = Math.cos(((angle_m / 180.0) * Math.PI)) * (((b + a) * (a - b)) * (2.0 * t_0));
} else {
tmp = (t_0 * (2.0 * ((b + a) * (b - a)))) * Math.pow(Math.cbrt(Math.cos((Math.PI * (angle_m * 0.005555555555555556)))), 3.0);
}
return angle_s * tmp;
}
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = sin(Float64(0.005555555555555556 * Float64(angle_m * pi))) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+51) tmp = Float64(Float64(a - b) * Float64(Float64(angle_m * -0.011111111111111112) * Float64(pi * Float64(b + a)))); elseif (Float64(angle_m / 180.0) <= 1e+153) tmp = Float64(cos(Float64(Float64(angle_m / 180.0) * pi)) * Float64(Float64(Float64(b + a) * Float64(a - b)) * Float64(2.0 * t_0))); else tmp = Float64(Float64(t_0 * Float64(2.0 * Float64(Float64(b + a) * Float64(b - a)))) * (cbrt(cos(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 3.0)); end return Float64(angle_s * tmp) end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[Sin[N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+51], N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * -0.011111111111111112), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+153], N[(N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(b + a), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision] * N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$0 * N[(2.0 * N[(N[(b + a), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[N[Cos[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \sin \left(0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+51}:\\
\;\;\;\;\left(a - b\right) \cdot \left(\left(angle\_m \cdot -0.011111111111111112\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 10^{+153}:\\
\;\;\;\;\cos \left(\frac{angle\_m}{180} \cdot \pi\right) \cdot \left(\left(\left(b + a\right) \cdot \left(a - b\right)\right) \cdot \left(2 \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t\_0 \cdot \left(2 \cdot \left(\left(b + a\right) \cdot \left(b - a\right)\right)\right)\right) \cdot {\left(\sqrt[3]{\cos \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)}\right)}^{3}\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2e51Initial program 55.1%
Simplified56.1%
Taylor expanded in angle around 0 54.0%
unpow216.0%
unpow216.0%
difference-of-squares17.0%
Applied egg-rr56.2%
associate-*r*56.2%
associate-*r*56.2%
associate-*r*68.7%
*-commutative68.7%
Applied egg-rr68.7%
if 2e51 < (/.f64 angle #s(literal 180 binary64)) < 1e153Initial program 43.4%
Taylor expanded in b around 0 23.5%
Simplified49.9%
unpow249.9%
unpow249.9%
difference-of-squares49.9%
Applied egg-rr49.9%
if 1e153 < (/.f64 angle #s(literal 180 binary64)) Initial program 39.5%
unpow239.5%
unpow239.5%
difference-of-squares42.3%
Applied egg-rr42.3%
div-inv40.1%
metadata-eval40.1%
add-cube-cbrt40.1%
pow340.1%
Applied egg-rr40.1%
Taylor expanded in angle around inf 47.6%
Final simplification64.3%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (cos (* (/ angle_m 180.0) PI))) (t_1 (* (+ b a) (- a b))))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+51)
(* (- a b) (* (* angle_m -0.011111111111111112) (* PI (+ b a))))
(if (<= (/ angle_m 180.0) 1e+153)
(* t_0 (* t_1 (* 2.0 (sin (* 0.005555555555555556 (* angle_m PI))))))
(*
t_1
(* 2.0 (* t_0 (sin (* (* angle_m PI) -0.005555555555555556))))))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = cos(((angle_m / 180.0) * ((double) M_PI)));
double t_1 = (b + a) * (a - b);
double tmp;
if ((angle_m / 180.0) <= 2e+51) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (((double) M_PI) * (b + a)));
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = t_0 * (t_1 * (2.0 * sin((0.005555555555555556 * (angle_m * ((double) M_PI))))));
} else {
tmp = t_1 * (2.0 * (t_0 * sin(((angle_m * ((double) M_PI)) * -0.005555555555555556))));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double t_0 = Math.cos(((angle_m / 180.0) * Math.PI));
double t_1 = (b + a) * (a - b);
double tmp;
if ((angle_m / 180.0) <= 2e+51) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (Math.PI * (b + a)));
} else if ((angle_m / 180.0) <= 1e+153) {
tmp = t_0 * (t_1 * (2.0 * Math.sin((0.005555555555555556 * (angle_m * Math.PI)))));
} else {
tmp = t_1 * (2.0 * (t_0 * Math.sin(((angle_m * Math.PI) * -0.005555555555555556))));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): t_0 = math.cos(((angle_m / 180.0) * math.pi)) t_1 = (b + a) * (a - b) tmp = 0 if (angle_m / 180.0) <= 2e+51: tmp = (a - b) * ((angle_m * -0.011111111111111112) * (math.pi * (b + a))) elif (angle_m / 180.0) <= 1e+153: tmp = t_0 * (t_1 * (2.0 * math.sin((0.005555555555555556 * (angle_m * math.pi))))) else: tmp = t_1 * (2.0 * (t_0 * math.sin(((angle_m * math.pi) * -0.005555555555555556)))) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = cos(Float64(Float64(angle_m / 180.0) * pi)) t_1 = Float64(Float64(b + a) * Float64(a - b)) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+51) tmp = Float64(Float64(a - b) * Float64(Float64(angle_m * -0.011111111111111112) * Float64(pi * Float64(b + a)))); elseif (Float64(angle_m / 180.0) <= 1e+153) tmp = Float64(t_0 * Float64(t_1 * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(angle_m * pi)))))); else tmp = Float64(t_1 * Float64(2.0 * Float64(t_0 * sin(Float64(Float64(angle_m * pi) * -0.005555555555555556))))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) t_0 = cos(((angle_m / 180.0) * pi)); t_1 = (b + a) * (a - b); tmp = 0.0; if ((angle_m / 180.0) <= 2e+51) tmp = (a - b) * ((angle_m * -0.011111111111111112) * (pi * (b + a))); elseif ((angle_m / 180.0) <= 1e+153) tmp = t_0 * (t_1 * (2.0 * sin((0.005555555555555556 * (angle_m * pi))))); else tmp = t_1 * (2.0 * (t_0 * sin(((angle_m * pi) * -0.005555555555555556)))); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(b + a), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+51], N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * -0.011111111111111112), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+153], N[(t$95$0 * N[(t$95$1 * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(2.0 * N[(t$95$0 * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] * -0.005555555555555556), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \cos \left(\frac{angle\_m}{180} \cdot \pi\right)\\
t_1 := \left(b + a\right) \cdot \left(a - b\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+51}:\\
\;\;\;\;\left(a - b\right) \cdot \left(\left(angle\_m \cdot -0.011111111111111112\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 10^{+153}:\\
\;\;\;\;t\_0 \cdot \left(t\_1 \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(2 \cdot \left(t\_0 \cdot \sin \left(\left(angle\_m \cdot \pi\right) \cdot -0.005555555555555556\right)\right)\right)\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2e51Initial program 55.1%
Simplified56.1%
Taylor expanded in angle around 0 54.0%
unpow216.0%
unpow216.0%
difference-of-squares17.0%
Applied egg-rr56.2%
associate-*r*56.2%
associate-*r*56.2%
associate-*r*68.7%
*-commutative68.7%
Applied egg-rr68.7%
if 2e51 < (/.f64 angle #s(literal 180 binary64)) < 1e153Initial program 43.4%
Taylor expanded in b around 0 23.5%
Simplified49.9%
unpow249.9%
unpow249.9%
difference-of-squares49.9%
Applied egg-rr49.9%
if 1e153 < (/.f64 angle #s(literal 180 binary64)) Initial program 39.5%
Simplified44.1%
unpow223.9%
unpow223.9%
difference-of-squares29.6%
Applied egg-rr49.9%
Final simplification64.7%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (* (/ angle_m 180.0) PI)) (t_1 (* 2.0 (* (+ b a) (- b a)))))
(*
angle_s
(if (<= (/ angle_m 180.0) 1e-134)
(* (- a b) (* (* angle_m -0.011111111111111112) (* PI (+ b a))))
(if (<= (/ angle_m 180.0) 4e+174)
(* (cos t_0) (* t_1 (sin (* PI (* angle_m 0.005555555555555556)))))
(* t_1 (sin t_0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = (angle_m / 180.0) * ((double) M_PI);
double t_1 = 2.0 * ((b + a) * (b - a));
double tmp;
if ((angle_m / 180.0) <= 1e-134) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (((double) M_PI) * (b + a)));
} else if ((angle_m / 180.0) <= 4e+174) {
tmp = cos(t_0) * (t_1 * sin((((double) M_PI) * (angle_m * 0.005555555555555556))));
} else {
tmp = t_1 * sin(t_0);
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double t_0 = (angle_m / 180.0) * Math.PI;
double t_1 = 2.0 * ((b + a) * (b - a));
double tmp;
if ((angle_m / 180.0) <= 1e-134) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (Math.PI * (b + a)));
} else if ((angle_m / 180.0) <= 4e+174) {
tmp = Math.cos(t_0) * (t_1 * Math.sin((Math.PI * (angle_m * 0.005555555555555556))));
} else {
tmp = t_1 * Math.sin(t_0);
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): t_0 = (angle_m / 180.0) * math.pi t_1 = 2.0 * ((b + a) * (b - a)) tmp = 0 if (angle_m / 180.0) <= 1e-134: tmp = (a - b) * ((angle_m * -0.011111111111111112) * (math.pi * (b + a))) elif (angle_m / 180.0) <= 4e+174: tmp = math.cos(t_0) * (t_1 * math.sin((math.pi * (angle_m * 0.005555555555555556)))) else: tmp = t_1 * math.sin(t_0) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = Float64(Float64(angle_m / 180.0) * pi) t_1 = Float64(2.0 * Float64(Float64(b + a) * Float64(b - a))) tmp = 0.0 if (Float64(angle_m / 180.0) <= 1e-134) tmp = Float64(Float64(a - b) * Float64(Float64(angle_m * -0.011111111111111112) * Float64(pi * Float64(b + a)))); elseif (Float64(angle_m / 180.0) <= 4e+174) tmp = Float64(cos(t_0) * Float64(t_1 * sin(Float64(pi * Float64(angle_m * 0.005555555555555556))))); else tmp = Float64(t_1 * sin(t_0)); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) t_0 = (angle_m / 180.0) * pi; t_1 = 2.0 * ((b + a) * (b - a)); tmp = 0.0; if ((angle_m / 180.0) <= 1e-134) tmp = (a - b) * ((angle_m * -0.011111111111111112) * (pi * (b + a))); elseif ((angle_m / 180.0) <= 4e+174) tmp = cos(t_0) * (t_1 * sin((pi * (angle_m * 0.005555555555555556)))); else tmp = t_1 * sin(t_0); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, Block[{t$95$1 = N[(2.0 * N[(N[(b + a), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e-134], N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * -0.011111111111111112), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 4e+174], N[(N[Cos[t$95$0], $MachinePrecision] * N[(t$95$1 * N[Sin[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \frac{angle\_m}{180} \cdot \pi\\
t_1 := 2 \cdot \left(\left(b + a\right) \cdot \left(b - a\right)\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 10^{-134}:\\
\;\;\;\;\left(a - b\right) \cdot \left(\left(angle\_m \cdot -0.011111111111111112\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 4 \cdot 10^{+174}:\\
\;\;\;\;\cos t\_0 \cdot \left(t\_1 \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \sin t\_0\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.00000000000000004e-134Initial program 47.8%
Simplified48.8%
Taylor expanded in angle around 0 48.0%
unpow217.3%
unpow217.3%
difference-of-squares18.6%
Applied egg-rr50.1%
associate-*r*50.0%
associate-*r*50.1%
associate-*r*65.8%
*-commutative65.8%
Applied egg-rr65.8%
if 1.00000000000000004e-134 < (/.f64 angle #s(literal 180 binary64)) < 4.00000000000000028e174Initial program 69.8%
unpow269.8%
unpow269.8%
difference-of-squares71.3%
Applied egg-rr71.3%
*-commutative71.3%
div-inv72.8%
metadata-eval72.8%
*-commutative72.8%
associate-*r*67.4%
*-commutative67.4%
*-commutative67.4%
associate-*r*72.8%
Applied egg-rr72.8%
if 4.00000000000000028e174 < (/.f64 angle #s(literal 180 binary64)) Initial program 35.1%
unpow235.1%
unpow235.1%
difference-of-squares38.4%
Applied egg-rr38.4%
Taylor expanded in angle around 0 51.6%
Final simplification66.0%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 1e+76)
(* (- a b) (* (* angle_m -0.011111111111111112) (* PI (+ b a))))
(* (* 2.0 (* (+ b a) (- b a))) (sin (* (/ angle_m 180.0) PI))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+76) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (((double) M_PI) * (b + a)));
} else {
tmp = (2.0 * ((b + a) * (b - a))) * sin(((angle_m / 180.0) * ((double) M_PI)));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+76) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * (Math.PI * (b + a)));
} else {
tmp = (2.0 * ((b + a) * (b - a))) * Math.sin(((angle_m / 180.0) * Math.PI));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 1e+76: tmp = (a - b) * ((angle_m * -0.011111111111111112) * (math.pi * (b + a))) else: tmp = (2.0 * ((b + a) * (b - a))) * math.sin(((angle_m / 180.0) * math.pi)) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 1e+76) tmp = Float64(Float64(a - b) * Float64(Float64(angle_m * -0.011111111111111112) * Float64(pi * Float64(b + a)))); else tmp = Float64(Float64(2.0 * Float64(Float64(b + a) * Float64(b - a))) * sin(Float64(Float64(angle_m / 180.0) * pi))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 1e+76) tmp = (a - b) * ((angle_m * -0.011111111111111112) * (pi * (b + a))); else tmp = (2.0 * ((b + a) * (b - a))) * sin(((angle_m / 180.0) * pi)); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+76], N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * -0.011111111111111112), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b + a), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 10^{+76}:\\
\;\;\;\;\left(a - b\right) \cdot \left(\left(angle\_m \cdot -0.011111111111111112\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b + a\right) \cdot \left(b - a\right)\right)\right) \cdot \sin \left(\frac{angle\_m}{180} \cdot \pi\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1e76Initial program 54.7%
Simplified55.6%
Taylor expanded in angle around 0 54.0%
unpow216.8%
unpow216.8%
difference-of-squares17.8%
Applied egg-rr56.1%
associate-*r*56.1%
associate-*r*56.2%
associate-*r*67.9%
*-commutative67.9%
Applied egg-rr67.9%
if 1e76 < (/.f64 angle #s(literal 180 binary64)) Initial program 41.4%
unpow241.4%
unpow241.4%
difference-of-squares43.3%
Applied egg-rr43.3%
Taylor expanded in angle around 0 50.1%
Final simplification64.4%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (* PI (+ b a))))
(*
angle_s
(if (<= angle_m 1.5e-114)
(* (- a b) (* (* angle_m -0.011111111111111112) t_0))
(* -0.011111111111111112 (* angle_m (* (- a b) t_0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (b + a);
double tmp;
if (angle_m <= 1.5e-114) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * t_0);
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double t_0 = Math.PI * (b + a);
double tmp;
if (angle_m <= 1.5e-114) {
tmp = (a - b) * ((angle_m * -0.011111111111111112) * t_0);
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): t_0 = math.pi * (b + a) tmp = 0 if angle_m <= 1.5e-114: tmp = (a - b) * ((angle_m * -0.011111111111111112) * t_0) else: tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0)) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = Float64(pi * Float64(b + a)) tmp = 0.0 if (angle_m <= 1.5e-114) tmp = Float64(Float64(a - b) * Float64(Float64(angle_m * -0.011111111111111112) * t_0)); else tmp = Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * t_0))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) t_0 = pi * (b + a); tmp = 0.0; if (angle_m <= 1.5e-114) tmp = (a - b) * ((angle_m * -0.011111111111111112) * t_0); else tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0)); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 1.5e-114], N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * -0.011111111111111112), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(b + a\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.5 \cdot 10^{-114}:\\
\;\;\;\;\left(a - b\right) \cdot \left(\left(angle\_m \cdot -0.011111111111111112\right) \cdot t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot t\_0\right)\right)\\
\end{array}
\end{array}
\end{array}
if angle < 1.50000000000000008e-114Initial program 48.1%
Simplified49.1%
Taylor expanded in angle around 0 48.3%
unpow217.2%
unpow217.2%
difference-of-squares18.5%
Applied egg-rr50.4%
associate-*r*50.4%
associate-*r*50.4%
associate-*r*66.1%
*-commutative66.1%
Applied egg-rr66.1%
if 1.50000000000000008e-114 < angle Initial program 58.6%
Simplified56.7%
Taylor expanded in angle around 0 50.2%
unpow224.0%
unpow224.0%
difference-of-squares26.1%
Applied egg-rr53.3%
associate-*r*53.4%
*-commutative53.4%
Applied egg-rr53.4%
Final simplification61.3%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 7.5e-20)
(* -0.011111111111111112 (* (- a b) (* (* angle_m PI) (+ b a))))
(* -0.011111111111111112 (* angle_m (* (- a b) (* PI (+ b a))))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if (angle_m <= 7.5e-20) {
tmp = -0.011111111111111112 * ((a - b) * ((angle_m * ((double) M_PI)) * (b + a)));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (((double) M_PI) * (b + a))));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if (angle_m <= 7.5e-20) {
tmp = -0.011111111111111112 * ((a - b) * ((angle_m * Math.PI) * (b + a)));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (Math.PI * (b + a))));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): tmp = 0 if angle_m <= 7.5e-20: tmp = -0.011111111111111112 * ((a - b) * ((angle_m * math.pi) * (b + a))) else: tmp = -0.011111111111111112 * (angle_m * ((a - b) * (math.pi * (b + a)))) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) tmp = 0.0 if (angle_m <= 7.5e-20) tmp = Float64(-0.011111111111111112 * Float64(Float64(a - b) * Float64(Float64(angle_m * pi) * Float64(b + a)))); else tmp = Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * Float64(pi * Float64(b + a))))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) tmp = 0.0; if (angle_m <= 7.5e-20) tmp = -0.011111111111111112 * ((a - b) * ((angle_m * pi) * (b + a))); else tmp = -0.011111111111111112 * (angle_m * ((a - b) * (pi * (b + a)))); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 7.5e-20], N[(-0.011111111111111112 * N[(N[(a - b), $MachinePrecision] * N[(N[(angle$95$m * Pi), $MachinePrecision] * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 7.5 \cdot 10^{-20}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(\left(a - b\right) \cdot \left(\left(angle\_m \cdot \pi\right) \cdot \left(b + a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 7.49999999999999981e-20Initial program 54.3%
Simplified55.1%
Taylor expanded in angle around 0 54.4%
unpow216.7%
unpow216.7%
difference-of-squares17.8%
Applied egg-rr56.8%
associate-*r*56.8%
associate-*r*70.0%
Applied egg-rr70.0%
if 7.49999999999999981e-20 < angle Initial program 46.4%
Simplified43.7%
Taylor expanded in angle around 0 35.2%
unpow227.6%
unpow227.6%
difference-of-squares30.3%
Applied egg-rr38.0%
associate-*r*38.0%
*-commutative38.0%
Applied egg-rr38.0%
Final simplification61.0%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(let* ((t_0 (* PI (+ b a))))
(*
angle_s
(if (<= angle_m 2.6e-131)
(* -0.011111111111111112 (* (- a b) (* angle_m t_0)))
(* -0.011111111111111112 (* angle_m (* (- a b) t_0)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (b + a);
double tmp;
if (angle_m <= 2.6e-131) {
tmp = -0.011111111111111112 * ((a - b) * (angle_m * t_0));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double t_0 = Math.PI * (b + a);
double tmp;
if (angle_m <= 2.6e-131) {
tmp = -0.011111111111111112 * ((a - b) * (angle_m * t_0));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): t_0 = math.pi * (b + a) tmp = 0 if angle_m <= 2.6e-131: tmp = -0.011111111111111112 * ((a - b) * (angle_m * t_0)) else: tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0)) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) t_0 = Float64(pi * Float64(b + a)) tmp = 0.0 if (angle_m <= 2.6e-131) tmp = Float64(-0.011111111111111112 * Float64(Float64(a - b) * Float64(angle_m * t_0))); else tmp = Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * t_0))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) t_0 = pi * (b + a); tmp = 0.0; if (angle_m <= 2.6e-131) tmp = -0.011111111111111112 * ((a - b) * (angle_m * t_0)); else tmp = -0.011111111111111112 * (angle_m * ((a - b) * t_0)); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 2.6e-131], N[(-0.011111111111111112 * N[(N[(a - b), $MachinePrecision] * N[(angle$95$m * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(b + a\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 2.6 \cdot 10^{-131}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(\left(a - b\right) \cdot \left(angle\_m \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot t\_0\right)\right)\\
\end{array}
\end{array}
\end{array}
if angle < 2.59999999999999996e-131Initial program 47.8%
Simplified48.8%
Taylor expanded in angle around 0 48.0%
unpow217.3%
unpow217.3%
difference-of-squares18.6%
Applied egg-rr50.1%
associate-*r*50.1%
associate-*r*65.4%
Applied egg-rr65.4%
if 2.59999999999999996e-131 < angle Initial program 59.1%
Simplified57.1%
Taylor expanded in angle around 0 50.7%
unpow223.8%
unpow223.8%
difference-of-squares25.8%
Applied egg-rr53.8%
associate-*r*53.8%
*-commutative53.8%
Applied egg-rr53.8%
Final simplification61.0%
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a b angle_m)
:precision binary64
(*
angle_s
(if (<= b 6.2e-78)
(* -0.011111111111111112 (* angle_m (* (- a b) (* PI a))))
(* -0.011111111111111112 (* angle_m (* (- a b) (* b PI)))))))angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if (b <= 6.2e-78) {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (((double) M_PI) * a)));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (b * ((double) M_PI))));
}
return angle_s * tmp;
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
double tmp;
if (b <= 6.2e-78) {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (Math.PI * a)));
} else {
tmp = -0.011111111111111112 * (angle_m * ((a - b) * (b * Math.PI)));
}
return angle_s * tmp;
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): tmp = 0 if b <= 6.2e-78: tmp = -0.011111111111111112 * (angle_m * ((a - b) * (math.pi * a))) else: tmp = -0.011111111111111112 * (angle_m * ((a - b) * (b * math.pi))) return angle_s * tmp
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) tmp = 0.0 if (b <= 6.2e-78) tmp = Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * Float64(pi * a)))); else tmp = Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * Float64(b * pi)))); end return Float64(angle_s * tmp) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a, b, angle_m) tmp = 0.0; if (b <= 6.2e-78) tmp = -0.011111111111111112 * (angle_m * ((a - b) * (pi * a))); else tmp = -0.011111111111111112 * (angle_m * ((a - b) * (b * pi))); end tmp_2 = angle_s * tmp; end
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_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b, 6.2e-78], N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * N[(b * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b \leq 6.2 \cdot 10^{-78}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot \left(\pi \cdot a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot \left(b \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if b < 6.20000000000000035e-78Initial program 52.8%
Simplified54.1%
Taylor expanded in angle around 0 53.0%
unpow221.5%
unpow221.5%
difference-of-squares23.2%
Applied egg-rr55.8%
associate-*r*55.9%
*-commutative55.9%
Applied egg-rr55.9%
Taylor expanded in a around inf 40.2%
if 6.20000000000000035e-78 < b Initial program 50.4%
Simplified46.8%
Taylor expanded in angle around 0 39.5%
unpow215.6%
unpow215.6%
difference-of-squares16.9%
Applied egg-rr41.1%
associate-*r*41.2%
*-commutative41.2%
Applied egg-rr41.2%
Taylor expanded in a around 0 36.1%
*-commutative36.1%
Simplified36.1%
Final simplification39.0%
angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a b angle_m) :precision binary64 (* angle_s (* -0.011111111111111112 (* angle_m (* (- a b) (* PI (+ b a)))))))
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (((double) M_PI) * (b + a)))));
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (Math.PI * (b + a)))));
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (math.pi * (b + a)))))
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) return Float64(angle_s * Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * Float64(pi * Float64(b + a)))))) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a, b, angle_m) tmp = angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (pi * (b + a))))); end
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_, b_, angle$95$m_] := N[(angle$95$s * N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * N[(Pi * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot \left(\pi \cdot \left(b + a\right)\right)\right)\right)\right)
\end{array}
Initial program 52.1%
Simplified51.9%
Taylor expanded in angle around 0 49.0%
unpow219.8%
unpow219.8%
difference-of-squares21.3%
Applied egg-rr51.5%
associate-*r*51.5%
*-commutative51.5%
Applied egg-rr51.5%
Final simplification51.5%
angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a b angle_m) :precision binary64 (* angle_s (* -0.011111111111111112 (* angle_m (* PI (* (+ b a) (- a b)))))))
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a) * (a - b)))));
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * (Math.PI * ((b + a) * (a - b)))));
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): return angle_s * (-0.011111111111111112 * (angle_m * (math.pi * ((b + a) * (a - b)))))
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) return Float64(angle_s * Float64(-0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a) * Float64(a - b)))))) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a, b, angle_m) tmp = angle_s * (-0.011111111111111112 * (angle_m * (pi * ((b + a) * (a - b))))); end
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_, b_, angle$95$m_] := N[(angle$95$s * N[(-0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a), $MachinePrecision] * N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\right) \cdot \left(a - b\right)\right)\right)\right)\right)
\end{array}
Initial program 52.1%
Simplified51.9%
Taylor expanded in angle around 0 49.0%
unpow219.8%
unpow219.8%
difference-of-squares21.3%
Applied egg-rr51.5%
Final simplification51.5%
angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a b angle_m) :precision binary64 (* angle_s (* -0.011111111111111112 (* angle_m (* (- a b) (* PI a))))))
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (((double) M_PI) * a))));
}
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (Math.PI * a))));
}
angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a, b, angle_m): return angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (math.pi * a))))
angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a, b, angle_m) return Float64(angle_s * Float64(-0.011111111111111112 * Float64(angle_m * Float64(Float64(a - b) * Float64(pi * a))))) end
angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a, b, angle_m) tmp = angle_s * (-0.011111111111111112 * (angle_m * ((a - b) * (pi * a)))); end
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_, b_, angle$95$m_] := N[(angle$95$s * N[(-0.011111111111111112 * N[(angle$95$m * N[(N[(a - b), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(-0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(a - b\right) \cdot \left(\pi \cdot a\right)\right)\right)\right)
\end{array}
Initial program 52.1%
Simplified51.9%
Taylor expanded in angle around 0 49.0%
unpow219.8%
unpow219.8%
difference-of-squares21.3%
Applied egg-rr51.5%
associate-*r*51.5%
*-commutative51.5%
Applied egg-rr51.5%
Taylor expanded in a around inf 33.1%
Final simplification33.1%
herbie shell --seed 2024096
(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)))))