
(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 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\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)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 1e+90)
(*
(+ b_m a_m)
(* (- b_m a_m) (sin (* PI (* (* angle_m 0.005555555555555556) 2.0)))))
(if (<= (/ angle_m 180.0) 2e+182)
(*
(+ b_m a_m)
(*
(- b_m a_m)
(pow
(cbrt (sin (* angle_m (* 0.011111111111111112 (cbrt (pow PI 3.0))))))
3.0)))
(if (<= (/ angle_m 180.0) 1e+278)
(pow
(cbrt
(*
(- (pow b_m 2.0) (pow a_m 2.0))
(sin
(* 2.0 (* PI (pow (cbrt (* angle_m 0.005555555555555556)) 3.0))))))
3.0)
(*
(* (+ b_m a_m) (- b_m a_m))
(*
2.0
(*
(sin (/ 1.0 (/ 180.0 (* angle_m PI))))
(cos (* (/ angle_m 180.0) PI))))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+90) {
tmp = (b_m + a_m) * ((b_m - a_m) * sin((((double) M_PI) * ((angle_m * 0.005555555555555556) * 2.0))));
} else if ((angle_m / 180.0) <= 2e+182) {
tmp = (b_m + a_m) * ((b_m - a_m) * pow(cbrt(sin((angle_m * (0.011111111111111112 * cbrt(pow(((double) M_PI), 3.0)))))), 3.0));
} else if ((angle_m / 180.0) <= 1e+278) {
tmp = pow(cbrt(((pow(b_m, 2.0) - pow(a_m, 2.0)) * sin((2.0 * (((double) M_PI) * pow(cbrt((angle_m * 0.005555555555555556)), 3.0)))))), 3.0);
} else {
tmp = ((b_m + a_m) * (b_m - a_m)) * (2.0 * (sin((1.0 / (180.0 / (angle_m * ((double) M_PI))))) * cos(((angle_m / 180.0) * ((double) M_PI)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+90) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.sin((Math.PI * ((angle_m * 0.005555555555555556) * 2.0))));
} else if ((angle_m / 180.0) <= 2e+182) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.pow(Math.cbrt(Math.sin((angle_m * (0.011111111111111112 * Math.cbrt(Math.pow(Math.PI, 3.0)))))), 3.0));
} else if ((angle_m / 180.0) <= 1e+278) {
tmp = Math.pow(Math.cbrt(((Math.pow(b_m, 2.0) - Math.pow(a_m, 2.0)) * Math.sin((2.0 * (Math.PI * Math.pow(Math.cbrt((angle_m * 0.005555555555555556)), 3.0)))))), 3.0);
} else {
tmp = ((b_m + a_m) * (b_m - a_m)) * (2.0 * (Math.sin((1.0 / (180.0 / (angle_m * Math.PI)))) * Math.cos(((angle_m / 180.0) * Math.PI))));
}
return angle_s * tmp;
}
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 1e+90) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin(Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * 2.0))))); elseif (Float64(angle_m / 180.0) <= 2e+182) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * (cbrt(sin(Float64(angle_m * Float64(0.011111111111111112 * cbrt((pi ^ 3.0)))))) ^ 3.0))); elseif (Float64(angle_m / 180.0) <= 1e+278) tmp = cbrt(Float64(Float64((b_m ^ 2.0) - (a_m ^ 2.0)) * sin(Float64(2.0 * Float64(pi * (cbrt(Float64(angle_m * 0.005555555555555556)) ^ 3.0)))))) ^ 3.0; else tmp = Float64(Float64(Float64(b_m + a_m) * Float64(b_m - a_m)) * Float64(2.0 * Float64(sin(Float64(1.0 / Float64(180.0 / Float64(angle_m * pi)))) * cos(Float64(Float64(angle_m / 180.0) * pi))))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+90], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+182], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Power[N[Power[N[Sin[N[(angle$95$m * N[(0.011111111111111112 * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+278], N[Power[N[Power[N[(N[(N[Power[b$95$m, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(2.0 * N[(Pi * N[Power[N[Power[N[(angle$95$m * 0.005555555555555556), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision], N[(N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(N[Sin[N[(1.0 / N[(180.0 / N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
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^{+90}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot 2\right)\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+182}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot {\left(\sqrt[3]{\sin \left(angle\_m \cdot \left(0.011111111111111112 \cdot \sqrt[3]{{\pi}^{3}}\right)\right)}\right)}^{3}\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 10^{+278}:\\
\;\;\;\;{\left(\sqrt[3]{\left({b\_m}^{2} - {a\_m}^{2}\right) \cdot \sin \left(2 \cdot \left(\pi \cdot {\left(\sqrt[3]{angle\_m \cdot 0.005555555555555556}\right)}^{3}\right)\right)}\right)}^{3}\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b\_m + a\_m\right) \cdot \left(b\_m - a\_m\right)\right) \cdot \left(2 \cdot \left(\sin \left(\frac{1}{\frac{180}{angle\_m \cdot \pi}}\right) \cdot \cos \left(\frac{angle\_m}{180} \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999966e89Initial program 61.3%
associate-*l*61.3%
*-commutative61.3%
associate-*l*61.3%
Simplified61.3%
associate-*r*61.3%
*-commutative61.3%
associate-*l*61.3%
add-cbrt-cube49.5%
pow1/334.4%
Applied egg-rr34.4%
unpow1/349.8%
rem-cbrt-cube61.8%
unpow261.8%
unpow261.8%
difference-of-squares65.1%
*-commutative65.1%
metadata-eval65.1%
div-inv64.7%
2-sin64.7%
associate-*l*77.7%
2-sin77.7%
div-inv78.1%
metadata-eval78.1%
Applied egg-rr78.1%
if 9.99999999999999966e89 < (/.f64 angle #s(literal 180 binary64)) < 2.0000000000000001e182Initial program 52.1%
associate-*l*52.1%
*-commutative52.1%
associate-*l*52.1%
Simplified52.1%
associate-*r*52.1%
*-commutative52.1%
associate-*l*52.1%
add-cbrt-cube53.1%
pow1/332.6%
Applied egg-rr32.6%
unpow1/353.1%
rem-cbrt-cube52.1%
unpow252.1%
unpow252.1%
difference-of-squares52.1%
*-commutative52.1%
metadata-eval52.1%
div-inv52.1%
2-sin52.1%
associate-*l*52.1%
2-sin52.1%
div-inv52.1%
metadata-eval52.1%
Applied egg-rr52.1%
associate-*r*52.1%
*-commutative52.1%
metadata-eval52.1%
div-inv52.1%
associate-*r/51.2%
associate-*l/45.0%
sin-245.0%
associate-*l/57.5%
associate-*r/45.0%
add-cube-cbrt45.0%
pow345.0%
Applied egg-rr45.0%
add-cbrt-cube63.8%
pow363.8%
Applied egg-rr63.8%
if 2.0000000000000001e182 < (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999964e277Initial program 33.9%
associate-*l*33.9%
*-commutative33.9%
associate-*l*33.9%
Simplified33.9%
associate-*r*33.9%
*-commutative33.9%
associate-*l*33.9%
add-cube-cbrt33.9%
pow333.9%
Applied egg-rr33.9%
add-cube-cbrt56.5%
pow361.3%
Applied egg-rr61.3%
if 9.99999999999999964e277 < (/.f64 angle #s(literal 180 binary64)) Initial program 58.1%
associate-*l*58.1%
*-commutative58.1%
associate-*l*58.1%
Simplified58.1%
unpow258.1%
unpow258.1%
difference-of-squares58.1%
Applied egg-rr58.1%
associate-*r/60.2%
*-commutative60.2%
clear-num58.1%
*-commutative58.1%
Applied egg-rr58.1%
Final simplification75.0%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(let* ((t_0 (* (/ angle_m 180.0) PI))
(t_1 (* angle_m (* PI 0.005555555555555556))))
(*
angle_s
(if (<=
(* (cos t_0) (* (* 2.0 (- (pow b_m 2.0) (pow a_m 2.0))) (sin t_0)))
-2e+264)
(*
(+ b_m a_m)
(*
(- b_m a_m)
(pow
(cbrt (sin (* angle_m (* 0.011111111111111112 (cbrt (pow PI 3.0))))))
3.0)))
(* (+ b_m a_m) (* (- b_m a_m) (* (* 2.0 (sin t_1)) (cos t_1))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = (angle_m / 180.0) * ((double) M_PI);
double t_1 = angle_m * (((double) M_PI) * 0.005555555555555556);
double tmp;
if ((cos(t_0) * ((2.0 * (pow(b_m, 2.0) - pow(a_m, 2.0))) * sin(t_0))) <= -2e+264) {
tmp = (b_m + a_m) * ((b_m - a_m) * pow(cbrt(sin((angle_m * (0.011111111111111112 * cbrt(pow(((double) M_PI), 3.0)))))), 3.0));
} else {
tmp = (b_m + a_m) * ((b_m - a_m) * ((2.0 * sin(t_1)) * cos(t_1)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = (angle_m / 180.0) * Math.PI;
double t_1 = angle_m * (Math.PI * 0.005555555555555556);
double tmp;
if ((Math.cos(t_0) * ((2.0 * (Math.pow(b_m, 2.0) - Math.pow(a_m, 2.0))) * Math.sin(t_0))) <= -2e+264) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.pow(Math.cbrt(Math.sin((angle_m * (0.011111111111111112 * Math.cbrt(Math.pow(Math.PI, 3.0)))))), 3.0));
} else {
tmp = (b_m + a_m) * ((b_m - a_m) * ((2.0 * Math.sin(t_1)) * Math.cos(t_1)));
}
return angle_s * tmp;
}
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) t_0 = Float64(Float64(angle_m / 180.0) * pi) t_1 = Float64(angle_m * Float64(pi * 0.005555555555555556)) tmp = 0.0 if (Float64(cos(t_0) * Float64(Float64(2.0 * Float64((b_m ^ 2.0) - (a_m ^ 2.0))) * sin(t_0))) <= -2e+264) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * (cbrt(sin(Float64(angle_m * Float64(0.011111111111111112 * cbrt((pi ^ 3.0)))))) ^ 3.0))); else tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * Float64(Float64(2.0 * sin(t_1)) * cos(t_1)))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := Block[{t$95$0 = N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, Block[{t$95$1 = N[(angle$95$m * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(N[Cos[t$95$0], $MachinePrecision] * N[(N[(2.0 * N[(N[Power[b$95$m, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -2e+264], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Power[N[Power[N[Sin[N[(angle$95$m * N[(0.011111111111111112 * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(N[(2.0 * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
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 := angle\_m \cdot \left(\pi \cdot 0.005555555555555556\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\cos t\_0 \cdot \left(\left(2 \cdot \left({b\_m}^{2} - {a\_m}^{2}\right)\right) \cdot \sin t\_0\right) \leq -2 \cdot 10^{+264}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot {\left(\sqrt[3]{\sin \left(angle\_m \cdot \left(0.011111111111111112 \cdot \sqrt[3]{{\pi}^{3}}\right)\right)}\right)}^{3}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \left(\left(2 \cdot \sin t\_1\right) \cdot \cos t\_1\right)\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < -2.00000000000000009e264Initial program 55.2%
associate-*l*55.2%
*-commutative55.2%
associate-*l*55.2%
Simplified55.2%
associate-*r*55.2%
*-commutative55.2%
associate-*l*55.2%
add-cbrt-cube55.2%
pow1/320.4%
Applied egg-rr20.4%
unpow1/357.2%
rem-cbrt-cube57.2%
unpow257.2%
unpow257.2%
difference-of-squares57.2%
*-commutative57.2%
metadata-eval57.2%
div-inv55.2%
2-sin55.2%
associate-*l*75.9%
2-sin75.9%
div-inv77.9%
metadata-eval77.9%
Applied egg-rr77.9%
associate-*r*77.9%
*-commutative77.9%
metadata-eval77.9%
div-inv75.9%
associate-*r/72.4%
associate-*l/77.9%
sin-277.9%
associate-*l/75.9%
associate-*r/79.9%
add-cube-cbrt79.6%
pow379.6%
Applied egg-rr77.6%
add-cbrt-cube74.0%
pow374.0%
Applied egg-rr74.0%
if -2.00000000000000009e264 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 58.7%
associate-*l*58.6%
*-commutative58.6%
associate-*l*58.6%
Simplified58.6%
associate-*r*58.6%
*-commutative58.6%
associate-*l*58.7%
add-cbrt-cube47.0%
pow1/340.7%
Applied egg-rr40.7%
unpow1/346.9%
rem-cbrt-cube58.6%
unpow258.6%
unpow258.6%
difference-of-squares63.0%
*-commutative63.0%
metadata-eval63.0%
div-inv62.5%
2-sin62.5%
associate-*l*70.5%
2-sin70.5%
div-inv71.0%
metadata-eval71.0%
Applied egg-rr71.0%
associate-*r*71.0%
*-commutative71.0%
metadata-eval71.0%
div-inv70.5%
associate-*r/69.0%
associate-*l/70.0%
sin-270.0%
associate-*l/70.5%
associate-*r/69.1%
associate-*r*69.1%
*-commutative69.1%
div-inv69.1%
metadata-eval69.1%
associate-*r/70.5%
Applied egg-rr70.0%
Final simplification70.8%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= (- (pow b_m 2.0) (pow a_m 2.0)) 1e-18)
(* (+ b_m a_m) (* (- b_m a_m) (sin (* PI (/ 2.0 (/ 180.0 angle_m))))))
(*
(+ b_m a_m)
(*
(sin (* PI (* (* angle_m 0.005555555555555556) 2.0)))
(fabs (- b_m a_m)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((pow(b_m, 2.0) - pow(a_m, 2.0)) <= 1e-18) {
tmp = (b_m + a_m) * ((b_m - a_m) * sin((((double) M_PI) * (2.0 / (180.0 / angle_m)))));
} else {
tmp = (b_m + a_m) * (sin((((double) M_PI) * ((angle_m * 0.005555555555555556) * 2.0))) * fabs((b_m - a_m)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((Math.pow(b_m, 2.0) - Math.pow(a_m, 2.0)) <= 1e-18) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.sin((Math.PI * (2.0 / (180.0 / angle_m)))));
} else {
tmp = (b_m + a_m) * (Math.sin((Math.PI * ((angle_m * 0.005555555555555556) * 2.0))) * Math.abs((b_m - a_m)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if (math.pow(b_m, 2.0) - math.pow(a_m, 2.0)) <= 1e-18: tmp = (b_m + a_m) * ((b_m - a_m) * math.sin((math.pi * (2.0 / (180.0 / angle_m))))) else: tmp = (b_m + a_m) * (math.sin((math.pi * ((angle_m * 0.005555555555555556) * 2.0))) * math.fabs((b_m - a_m))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (Float64((b_m ^ 2.0) - (a_m ^ 2.0)) <= 1e-18) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin(Float64(pi * Float64(2.0 / Float64(180.0 / angle_m)))))); else tmp = Float64(Float64(b_m + a_m) * Float64(sin(Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * 2.0))) * abs(Float64(b_m - a_m)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (((b_m ^ 2.0) - (a_m ^ 2.0)) <= 1e-18) tmp = (b_m + a_m) * ((b_m - a_m) * sin((pi * (2.0 / (180.0 / angle_m))))); else tmp = (b_m + a_m) * (sin((pi * ((angle_m * 0.005555555555555556) * 2.0))) * abs((b_m - a_m))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(N[Power[b$95$m, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision], 1e-18], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(2.0 / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[Sin[N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Abs[N[(b$95$m - a$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;{b\_m}^{2} - {a\_m}^{2} \leq 10^{-18}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot \frac{2}{\frac{180}{angle\_m}}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\sin \left(\pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot 2\right)\right) \cdot \left|b\_m - a\_m\right|\right)\\
\end{array}
\end{array}
if (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < 1.0000000000000001e-18Initial program 62.1%
associate-*l*62.1%
*-commutative62.1%
associate-*l*62.1%
Simplified62.1%
associate-*r*62.1%
*-commutative62.1%
associate-*l*62.1%
add-cbrt-cube48.7%
pow1/339.8%
Applied egg-rr39.8%
unpow1/347.9%
rem-cbrt-cube61.4%
unpow261.4%
unpow261.4%
difference-of-squares61.4%
*-commutative61.4%
metadata-eval61.4%
div-inv62.1%
2-sin62.1%
associate-*l*70.8%
2-sin70.8%
div-inv70.2%
metadata-eval70.2%
Applied egg-rr70.2%
*-commutative70.2%
metadata-eval70.2%
div-inv70.8%
clear-num71.4%
un-div-inv71.4%
Applied egg-rr71.4%
if 1.0000000000000001e-18 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) Initial program 50.3%
associate-*l*50.3%
*-commutative50.3%
associate-*l*50.3%
Simplified50.3%
associate-*r*50.3%
*-commutative50.3%
associate-*l*50.3%
add-cbrt-cube48.5%
pow1/331.1%
Applied egg-rr31.1%
unpow1/350.7%
rem-cbrt-cube52.6%
unpow252.6%
unpow252.6%
difference-of-squares62.7%
*-commutative62.7%
metadata-eval62.7%
div-inv59.3%
2-sin59.3%
associate-*l*73.0%
2-sin73.0%
div-inv76.3%
metadata-eval76.3%
Applied egg-rr76.3%
add-sqr-sqrt31.0%
sqrt-unprod41.0%
pow241.0%
Applied egg-rr37.8%
unpow241.0%
rem-sqrt-square41.0%
Simplified46.2%
Final simplification62.7%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+136)
(*
(+ b_m a_m)
(* (- b_m a_m) (sin (* PI (* (* angle_m 0.005555555555555556) 2.0)))))
(if (<= (/ angle_m 180.0) 5e+191)
(*
(+ b_m a_m)
(*
(- b_m a_m)
(sin (pow (cbrt (* angle_m (* PI 0.011111111111111112))) 3.0))))
(if (<= (/ angle_m 180.0) 2e+245)
(*
(+ b_m a_m)
(*
(- b_m a_m)
(sin (* PI (pow (cbrt (* angle_m 0.011111111111111112)) 3.0)))))
(*
(* (+ b_m a_m) (fabs (- b_m a_m)))
(*
2.0
(*
(cos (* (/ angle_m 180.0) PI))
(sin (* angle_m (/ PI 180.0)))))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+136) {
tmp = (b_m + a_m) * ((b_m - a_m) * sin((((double) M_PI) * ((angle_m * 0.005555555555555556) * 2.0))));
} else if ((angle_m / 180.0) <= 5e+191) {
tmp = (b_m + a_m) * ((b_m - a_m) * sin(pow(cbrt((angle_m * (((double) M_PI) * 0.011111111111111112))), 3.0)));
} else if ((angle_m / 180.0) <= 2e+245) {
tmp = (b_m + a_m) * ((b_m - a_m) * sin((((double) M_PI) * pow(cbrt((angle_m * 0.011111111111111112)), 3.0))));
} else {
tmp = ((b_m + a_m) * fabs((b_m - a_m))) * (2.0 * (cos(((angle_m / 180.0) * ((double) M_PI))) * sin((angle_m * (((double) M_PI) / 180.0)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+136) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.sin((Math.PI * ((angle_m * 0.005555555555555556) * 2.0))));
} else if ((angle_m / 180.0) <= 5e+191) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.sin(Math.pow(Math.cbrt((angle_m * (Math.PI * 0.011111111111111112))), 3.0)));
} else if ((angle_m / 180.0) <= 2e+245) {
tmp = (b_m + a_m) * ((b_m - a_m) * Math.sin((Math.PI * Math.pow(Math.cbrt((angle_m * 0.011111111111111112)), 3.0))));
} else {
tmp = ((b_m + a_m) * Math.abs((b_m - a_m))) * (2.0 * (Math.cos(((angle_m / 180.0) * Math.PI)) * Math.sin((angle_m * (Math.PI / 180.0)))));
}
return angle_s * tmp;
}
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+136) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin(Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * 2.0))))); elseif (Float64(angle_m / 180.0) <= 5e+191) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin((cbrt(Float64(angle_m * Float64(pi * 0.011111111111111112))) ^ 3.0)))); elseif (Float64(angle_m / 180.0) <= 2e+245) tmp = Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin(Float64(pi * (cbrt(Float64(angle_m * 0.011111111111111112)) ^ 3.0))))); else tmp = Float64(Float64(Float64(b_m + a_m) * abs(Float64(b_m - a_m))) * Float64(2.0 * Float64(cos(Float64(Float64(angle_m / 180.0) * pi)) * sin(Float64(angle_m * Float64(pi / 180.0)))))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+136], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 5e+191], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[Power[N[Power[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+245], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[Power[N[Power[N[(angle$95$m * 0.011111111111111112), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[Abs[N[(b$95$m - a$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(N[Cos[N[(N[(angle$95$m / 180.0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(angle$95$m * N[(Pi / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
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 2 \cdot 10^{+136}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot 2\right)\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 5 \cdot 10^{+191}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left({\left(\sqrt[3]{angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)}\right)}^{3}\right)\right)\\
\mathbf{elif}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+245}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot {\left(\sqrt[3]{angle\_m \cdot 0.011111111111111112}\right)}^{3}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b\_m + a\_m\right) \cdot \left|b\_m - a\_m\right|\right) \cdot \left(2 \cdot \left(\cos \left(\frac{angle\_m}{180} \cdot \pi\right) \cdot \sin \left(angle\_m \cdot \frac{\pi}{180}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000012e136Initial program 61.1%
associate-*l*61.1%
*-commutative61.1%
associate-*l*61.1%
Simplified61.1%
associate-*r*61.1%
*-commutative61.1%
associate-*l*61.1%
add-cbrt-cube49.6%
pow1/333.9%
Applied egg-rr33.9%
unpow1/349.9%
rem-cbrt-cube61.5%
unpow261.5%
unpow261.5%
difference-of-squares64.8%
*-commutative64.8%
metadata-eval64.8%
div-inv64.4%
2-sin64.4%
associate-*l*77.0%
2-sin77.0%
div-inv77.4%
metadata-eval77.4%
Applied egg-rr77.4%
if 2.00000000000000012e136 < (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000002e191Initial program 42.8%
associate-*l*42.8%
*-commutative42.8%
associate-*l*42.8%
Simplified42.8%
associate-*r*42.8%
*-commutative42.8%
associate-*l*42.8%
add-cbrt-cube44.9%
pow1/351.3%
Applied egg-rr51.3%
unpow1/344.9%
rem-cbrt-cube42.8%
unpow242.8%
unpow242.8%
difference-of-squares42.8%
*-commutative42.8%
metadata-eval42.8%
div-inv42.8%
2-sin42.8%
associate-*l*42.8%
2-sin42.8%
div-inv42.8%
metadata-eval42.8%
Applied egg-rr42.8%
add-cube-cbrt57.8%
pow357.8%
*-commutative57.8%
cbrt-prod56.8%
*-commutative56.8%
*-commutative56.8%
associate-*r*56.8%
metadata-eval56.8%
cbrt-prod57.8%
associate-*r*66.2%
*-commutative66.2%
associate-*r*66.2%
Applied egg-rr66.2%
if 5.0000000000000002e191 < (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000009e245Initial program 44.7%
associate-*l*44.7%
*-commutative44.7%
associate-*l*44.7%
Simplified44.7%
associate-*r*44.7%
*-commutative44.7%
associate-*l*44.7%
add-cbrt-cube43.0%
pow1/351.7%
Applied egg-rr51.7%
unpow1/343.0%
rem-cbrt-cube44.7%
unpow244.7%
unpow244.7%
difference-of-squares53.0%
*-commutative53.0%
metadata-eval53.0%
div-inv44.7%
2-sin44.7%
associate-*l*44.7%
2-sin44.7%
div-inv53.0%
metadata-eval53.0%
Applied egg-rr53.0%
add-cube-cbrt62.0%
pow363.6%
associate-*l*63.6%
metadata-eval63.6%
Applied egg-rr63.6%
if 2.00000000000000009e245 < (/.f64 angle #s(literal 180 binary64)) Initial program 40.9%
associate-*l*40.9%
*-commutative40.9%
associate-*l*40.9%
Simplified40.9%
unpow240.9%
unpow240.9%
difference-of-squares46.2%
Applied egg-rr46.2%
clear-num47.1%
un-div-inv47.0%
Applied egg-rr47.0%
associate-/r/46.1%
Simplified46.1%
add-sqr-sqrt27.5%
sqrt-unprod37.2%
pow237.2%
Applied egg-rr37.2%
unpow237.2%
rem-sqrt-square37.2%
Simplified37.2%
Final simplification73.3%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= (pow a_m 2.0) 2e-297)
(* b_m (* b_m (sin (* angle_m (* PI 0.011111111111111112)))))
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (pow(a_m, 2.0) <= 2e-297) {
tmp = b_m * (b_m * sin((angle_m * (((double) M_PI) * 0.011111111111111112))));
} else {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (Math.pow(a_m, 2.0) <= 2e-297) {
tmp = b_m * (b_m * Math.sin((angle_m * (Math.PI * 0.011111111111111112))));
} else {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if math.pow(a_m, 2.0) <= 2e-297: tmp = b_m * (b_m * math.sin((angle_m * (math.pi * 0.011111111111111112)))) else: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if ((a_m ^ 2.0) <= 2e-297) tmp = Float64(b_m * Float64(b_m * sin(Float64(angle_m * Float64(pi * 0.011111111111111112))))); else tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if ((a_m ^ 2.0) <= 2e-297) tmp = b_m * (b_m * sin((angle_m * (pi * 0.011111111111111112)))); else tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[Power[a$95$m, 2.0], $MachinePrecision], 2e-297], N[(b$95$m * N[(b$95$m * N[Sin[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;{a\_m}^{2} \leq 2 \cdot 10^{-297}:\\
\;\;\;\;b\_m \cdot \left(b\_m \cdot \sin \left(angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if (pow.f64 a #s(literal 2 binary64)) < 2.00000000000000008e-297Initial program 66.6%
associate-*l*66.6%
*-commutative66.6%
associate-*l*66.6%
Simplified66.6%
associate-*r*66.6%
*-commutative66.6%
associate-*l*66.6%
add-cbrt-cube60.8%
pow1/348.4%
Applied egg-rr48.4%
Taylor expanded in b around inf 48.4%
unpow1/362.2%
rem-cbrt-cube68.5%
*-commutative68.5%
unpow268.5%
associate-*r*74.0%
Applied egg-rr71.1%
if 2.00000000000000008e-297 < (pow.f64 a #s(literal 2 binary64)) Initial program 54.9%
associate-*l*54.9%
*-commutative54.9%
associate-*l*54.9%
Simplified54.9%
associate-*r*54.9%
*-commutative54.9%
associate-*l*54.9%
add-cbrt-cube44.3%
pow1/332.6%
Applied egg-rr32.6%
unpow1/344.2%
rem-cbrt-cube54.9%
unpow254.9%
unpow254.9%
difference-of-squares59.6%
*-commutative59.6%
metadata-eval59.6%
div-inv59.2%
2-sin59.2%
associate-*l*71.4%
2-sin71.4%
div-inv71.9%
metadata-eval71.9%
Applied egg-rr71.9%
Taylor expanded in angle around 0 65.9%
Final simplification67.3%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1e-26)
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI))))
(if (or (<= angle_m 5.8e+172) (not (<= angle_m 1.15e+186)))
(*
(* (+ b_m a_m) (- b_m a_m))
(sin (* PI (* angle_m 0.011111111111111112))))
(* (* a_m (- b_m a_m)) (* 0.011111111111111112 (* angle_m PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (angle_m <= 1e-26) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
} else if ((angle_m <= 5.8e+172) || !(angle_m <= 1.15e+186)) {
tmp = ((b_m + a_m) * (b_m - a_m)) * sin((((double) M_PI) * (angle_m * 0.011111111111111112)));
} else {
tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * ((double) M_PI)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (angle_m <= 1e-26) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
} else if ((angle_m <= 5.8e+172) || !(angle_m <= 1.15e+186)) {
tmp = ((b_m + a_m) * (b_m - a_m)) * Math.sin((Math.PI * (angle_m * 0.011111111111111112)));
} else {
tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * Math.PI));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if angle_m <= 1e-26: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) elif (angle_m <= 5.8e+172) or not (angle_m <= 1.15e+186): tmp = ((b_m + a_m) * (b_m - a_m)) * math.sin((math.pi * (angle_m * 0.011111111111111112))) else: tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * math.pi)) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (angle_m <= 1e-26) tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); elseif ((angle_m <= 5.8e+172) || !(angle_m <= 1.15e+186)) tmp = Float64(Float64(Float64(b_m + a_m) * Float64(b_m - a_m)) * sin(Float64(pi * Float64(angle_m * 0.011111111111111112)))); else tmp = Float64(Float64(a_m * Float64(b_m - a_m)) * Float64(0.011111111111111112 * Float64(angle_m * pi))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (angle_m <= 1e-26) tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); elseif ((angle_m <= 5.8e+172) || ~((angle_m <= 1.15e+186))) tmp = ((b_m + a_m) * (b_m - a_m)) * sin((pi * (angle_m * 0.011111111111111112))); else tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * pi)); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1e-26], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[angle$95$m, 5.8e+172], N[Not[LessEqual[angle$95$m, 1.15e+186]], $MachinePrecision]], N[(N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(a$95$m * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\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 10^{-26}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 5.8 \cdot 10^{+172} \lor \neg \left(angle\_m \leq 1.15 \cdot 10^{+186}\right):\\
\;\;\;\;\left(\left(b\_m + a\_m\right) \cdot \left(b\_m - a\_m\right)\right) \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a\_m \cdot \left(b\_m - a\_m\right)\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right)\\
\end{array}
\end{array}
if angle < 1e-26Initial program 62.7%
associate-*l*62.7%
*-commutative62.7%
associate-*l*62.7%
Simplified62.7%
associate-*r*62.7%
*-commutative62.7%
associate-*l*62.7%
add-cbrt-cube50.6%
pow1/333.2%
Applied egg-rr33.2%
unpow1/349.9%
rem-cbrt-cube62.1%
unpow262.1%
unpow262.1%
difference-of-squares65.3%
*-commutative65.3%
metadata-eval65.3%
div-inv65.9%
2-sin65.9%
associate-*l*80.4%
2-sin80.4%
div-inv79.8%
metadata-eval79.8%
Applied egg-rr79.8%
Taylor expanded in angle around 0 76.6%
if 1e-26 < angle < 5.7999999999999999e172 or 1.15000000000000007e186 < angle Initial program 47.5%
associate-*l*47.5%
*-commutative47.5%
associate-*l*47.5%
Simplified47.5%
unpow247.5%
unpow247.5%
difference-of-squares50.5%
Applied egg-rr50.5%
2-sin50.5%
div-inv55.1%
metadata-eval55.1%
*-commutative55.1%
add-log-exp4.1%
metadata-eval4.1%
div-inv4.1%
exp-lft-sqr4.0%
sum-log4.1%
add-log-exp4.4%
add-log-exp50.5%
sin-sum50.5%
Applied egg-rr55.1%
distribute-lft-out55.1%
sin-055.1%
+-lft-identity55.1%
metadata-eval55.1%
*-rgt-identity55.1%
associate-*l*55.1%
metadata-eval55.1%
Simplified55.1%
if 5.7999999999999999e172 < angle < 1.15000000000000007e186Initial program 23.2%
associate-*l*23.2%
*-commutative23.2%
associate-*l*23.2%
Simplified23.2%
unpow223.2%
unpow223.2%
difference-of-squares23.2%
Applied egg-rr23.2%
Taylor expanded in angle around 0 80.2%
Taylor expanded in b around 0 60.2%
Final simplification70.7%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(let* ((t_0 (* (+ b_m a_m) (- b_m a_m))))
(*
angle_s
(if (<= angle_m 1e-26)
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI))))
(if (<= angle_m 5.8e+172)
(* t_0 (sin (* PI (* angle_m 0.011111111111111112))))
(if (<= angle_m 4.1e+189)
(* (* a_m (- b_m a_m)) (* 0.011111111111111112 (* angle_m PI)))
(* t_0 (sin (* angle_m (* PI 0.011111111111111112))))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = (b_m + a_m) * (b_m - a_m);
double tmp;
if (angle_m <= 1e-26) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
} else if (angle_m <= 5.8e+172) {
tmp = t_0 * sin((((double) M_PI) * (angle_m * 0.011111111111111112)));
} else if (angle_m <= 4.1e+189) {
tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * ((double) M_PI)));
} else {
tmp = t_0 * sin((angle_m * (((double) M_PI) * 0.011111111111111112)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = (b_m + a_m) * (b_m - a_m);
double tmp;
if (angle_m <= 1e-26) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
} else if (angle_m <= 5.8e+172) {
tmp = t_0 * Math.sin((Math.PI * (angle_m * 0.011111111111111112)));
} else if (angle_m <= 4.1e+189) {
tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * Math.PI));
} else {
tmp = t_0 * Math.sin((angle_m * (Math.PI * 0.011111111111111112)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): t_0 = (b_m + a_m) * (b_m - a_m) tmp = 0 if angle_m <= 1e-26: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) elif angle_m <= 5.8e+172: tmp = t_0 * math.sin((math.pi * (angle_m * 0.011111111111111112))) elif angle_m <= 4.1e+189: tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * math.pi)) else: tmp = t_0 * math.sin((angle_m * (math.pi * 0.011111111111111112))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) t_0 = Float64(Float64(b_m + a_m) * Float64(b_m - a_m)) tmp = 0.0 if (angle_m <= 1e-26) tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); elseif (angle_m <= 5.8e+172) tmp = Float64(t_0 * sin(Float64(pi * Float64(angle_m * 0.011111111111111112)))); elseif (angle_m <= 4.1e+189) tmp = Float64(Float64(a_m * Float64(b_m - a_m)) * Float64(0.011111111111111112 * Float64(angle_m * pi))); else tmp = Float64(t_0 * sin(Float64(angle_m * Float64(pi * 0.011111111111111112)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) t_0 = (b_m + a_m) * (b_m - a_m); tmp = 0.0; if (angle_m <= 1e-26) tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); elseif (angle_m <= 5.8e+172) tmp = t_0 * sin((pi * (angle_m * 0.011111111111111112))); elseif (angle_m <= 4.1e+189) tmp = (a_m * (b_m - a_m)) * (0.011111111111111112 * (angle_m * pi)); else tmp = t_0 * sin((angle_m * (pi * 0.011111111111111112))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := Block[{t$95$0 = N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 1e-26], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 5.8e+172], N[(t$95$0 * N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 4.1e+189], N[(N[(a$95$m * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[Sin[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \left(b\_m + a\_m\right) \cdot \left(b\_m - a\_m\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 10^{-26}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 5.8 \cdot 10^{+172}:\\
\;\;\;\;t\_0 \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right)\\
\mathbf{elif}\;angle\_m \leq 4.1 \cdot 10^{+189}:\\
\;\;\;\;\left(a\_m \cdot \left(b\_m - a\_m\right)\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \sin \left(angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)\right)\\
\end{array}
\end{array}
\end{array}
if angle < 1e-26Initial program 62.7%
associate-*l*62.7%
*-commutative62.7%
associate-*l*62.7%
Simplified62.7%
associate-*r*62.7%
*-commutative62.7%
associate-*l*62.7%
add-cbrt-cube50.6%
pow1/333.2%
Applied egg-rr33.2%
unpow1/349.9%
rem-cbrt-cube62.1%
unpow262.1%
unpow262.1%
difference-of-squares65.3%
*-commutative65.3%
metadata-eval65.3%
div-inv65.9%
2-sin65.9%
associate-*l*80.4%
2-sin80.4%
div-inv79.8%
metadata-eval79.8%
Applied egg-rr79.8%
Taylor expanded in angle around 0 76.6%
if 1e-26 < angle < 5.7999999999999999e172Initial program 53.6%
associate-*l*53.5%
*-commutative53.5%
associate-*l*53.5%
Simplified53.5%
unpow253.5%
unpow253.5%
difference-of-squares56.5%
Applied egg-rr56.5%
2-sin56.5%
div-inv62.4%
metadata-eval62.4%
*-commutative62.4%
add-log-exp7.9%
metadata-eval7.9%
div-inv7.9%
exp-lft-sqr7.8%
sum-log7.9%
add-log-exp8.5%
add-log-exp56.5%
sin-sum56.5%
Applied egg-rr62.4%
distribute-lft-out62.4%
sin-062.4%
+-lft-identity62.4%
metadata-eval62.4%
*-rgt-identity62.4%
associate-*l*62.4%
metadata-eval62.4%
Simplified62.4%
if 5.7999999999999999e172 < angle < 4.1000000000000002e189Initial program 23.2%
associate-*l*23.2%
*-commutative23.2%
associate-*l*23.2%
Simplified23.2%
unpow223.2%
unpow223.2%
difference-of-squares23.2%
Applied egg-rr23.2%
Taylor expanded in angle around 0 80.2%
Taylor expanded in b around 0 60.2%
if 4.1000000000000002e189 < angle Initial program 41.0%
associate-*l*41.0%
*-commutative41.0%
associate-*l*41.0%
Simplified41.0%
unpow241.0%
unpow241.0%
difference-of-squares44.2%
Applied egg-rr44.2%
clear-num44.7%
un-div-inv42.1%
Applied egg-rr42.1%
associate-/r/47.8%
Simplified47.8%
associate-*r/47.2%
associate-*l/50.6%
sin-250.6%
associate-*l/44.3%
associate-*r/44.2%
div-inv47.3%
metadata-eval47.3%
*-commutative47.3%
associate-*r*47.3%
*-commutative47.3%
associate-*r*47.3%
metadata-eval47.3%
associate-*r*44.2%
*-commutative44.2%
associate-*r*50.6%
Applied egg-rr50.6%
Final simplification71.2%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= b_m 1.85e-63)
(* (+ b_m a_m) (* a_m (- (sin (* 0.011111111111111112 (* angle_m PI))))))
(if (<= b_m 1.3e+255)
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI))))
(*
b_m
(*
(- b_m a_m)
(sin (* PI (* (* angle_m 0.005555555555555556) 2.0)))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 1.85e-63) {
tmp = (b_m + a_m) * (a_m * -sin((0.011111111111111112 * (angle_m * ((double) M_PI)))));
} else if (b_m <= 1.3e+255) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
} else {
tmp = b_m * ((b_m - a_m) * sin((((double) M_PI) * ((angle_m * 0.005555555555555556) * 2.0))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 1.85e-63) {
tmp = (b_m + a_m) * (a_m * -Math.sin((0.011111111111111112 * (angle_m * Math.PI))));
} else if (b_m <= 1.3e+255) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
} else {
tmp = b_m * ((b_m - a_m) * Math.sin((Math.PI * ((angle_m * 0.005555555555555556) * 2.0))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if b_m <= 1.85e-63: tmp = (b_m + a_m) * (a_m * -math.sin((0.011111111111111112 * (angle_m * math.pi)))) elif b_m <= 1.3e+255: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) else: tmp = b_m * ((b_m - a_m) * math.sin((math.pi * ((angle_m * 0.005555555555555556) * 2.0)))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (b_m <= 1.85e-63) tmp = Float64(Float64(b_m + a_m) * Float64(a_m * Float64(-sin(Float64(0.011111111111111112 * Float64(angle_m * pi)))))); elseif (b_m <= 1.3e+255) tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); else tmp = Float64(b_m * Float64(Float64(b_m - a_m) * sin(Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * 2.0))))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (b_m <= 1.85e-63) tmp = (b_m + a_m) * (a_m * -sin((0.011111111111111112 * (angle_m * pi)))); elseif (b_m <= 1.3e+255) tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); else tmp = b_m * ((b_m - a_m) * sin((pi * ((angle_m * 0.005555555555555556) * 2.0)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b$95$m, 1.85e-63], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(a$95$m * (-N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[b$95$m, 1.3e+255], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b\_m \leq 1.85 \cdot 10^{-63}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(a\_m \cdot \left(-\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)\\
\mathbf{elif}\;b\_m \leq 1.3 \cdot 10^{+255}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot 2\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.85000000000000006e-63Initial program 62.9%
associate-*l*62.9%
*-commutative62.9%
associate-*l*62.9%
Simplified62.9%
associate-*r*62.9%
*-commutative62.9%
associate-*l*62.9%
add-cbrt-cube52.2%
pow1/340.8%
Applied egg-rr40.8%
unpow1/351.6%
rem-cbrt-cube62.4%
unpow262.4%
unpow262.4%
difference-of-squares63.5%
*-commutative63.5%
metadata-eval63.5%
div-inv64.0%
2-sin64.0%
associate-*l*73.4%
2-sin73.4%
div-inv72.9%
metadata-eval72.9%
Applied egg-rr72.9%
associate-*r*72.9%
*-commutative72.9%
metadata-eval72.9%
div-inv73.4%
associate-*r/71.4%
associate-*l/71.5%
sin-271.4%
associate-*l/72.3%
associate-*r/71.0%
add-cube-cbrt70.5%
pow370.5%
Applied egg-rr70.9%
Taylor expanded in b around 0 55.5%
mul-1-neg55.5%
*-commutative55.5%
distribute-rgt-neg-in55.5%
Simplified55.5%
if 1.85000000000000006e-63 < b < 1.30000000000000005e255Initial program 47.3%
associate-*l*47.3%
*-commutative47.3%
associate-*l*47.3%
Simplified47.3%
associate-*r*47.3%
*-commutative47.3%
associate-*l*47.3%
add-cbrt-cube40.3%
pow1/321.2%
Applied egg-rr21.2%
unpow1/338.1%
rem-cbrt-cube45.2%
unpow245.2%
unpow245.2%
difference-of-squares50.4%
*-commutative50.4%
metadata-eval50.4%
div-inv50.8%
2-sin50.8%
associate-*l*66.8%
2-sin66.8%
div-inv66.5%
metadata-eval66.5%
Applied egg-rr66.5%
Taylor expanded in angle around 0 69.3%
if 1.30000000000000005e255 < b Initial program 33.3%
associate-*l*33.3%
*-commutative33.3%
associate-*l*33.3%
Simplified33.3%
associate-*r*33.3%
*-commutative33.3%
associate-*l*33.3%
add-cbrt-cube33.3%
pow1/350.0%
Applied egg-rr50.0%
unpow1/358.3%
rem-cbrt-cube58.3%
unpow258.3%
unpow258.3%
difference-of-squares91.7%
*-commutative91.7%
metadata-eval91.7%
div-inv66.7%
2-sin66.7%
associate-*l*66.7%
2-sin66.7%
div-inv91.7%
metadata-eval91.7%
Applied egg-rr91.7%
Taylor expanded in b around inf 91.7%
Final simplification60.3%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= b_m 2.4e-62)
(* (+ b_m a_m) (* a_m (- (sin (* 0.011111111111111112 (* angle_m PI))))))
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 2.4e-62) {
tmp = (b_m + a_m) * (a_m * -sin((0.011111111111111112 * (angle_m * ((double) M_PI)))));
} else {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 2.4e-62) {
tmp = (b_m + a_m) * (a_m * -Math.sin((0.011111111111111112 * (angle_m * Math.PI))));
} else {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if b_m <= 2.4e-62: tmp = (b_m + a_m) * (a_m * -math.sin((0.011111111111111112 * (angle_m * math.pi)))) else: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (b_m <= 2.4e-62) tmp = Float64(Float64(b_m + a_m) * Float64(a_m * Float64(-sin(Float64(0.011111111111111112 * Float64(angle_m * pi)))))); else tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (b_m <= 2.4e-62) tmp = (b_m + a_m) * (a_m * -sin((0.011111111111111112 * (angle_m * pi)))); else tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b$95$m, 2.4e-62], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(a$95$m * (-N[Sin[N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b\_m \leq 2.4 \cdot 10^{-62}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(a\_m \cdot \left(-\sin \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if b < 2.39999999999999984e-62Initial program 62.9%
associate-*l*62.9%
*-commutative62.9%
associate-*l*62.9%
Simplified62.9%
associate-*r*62.9%
*-commutative62.9%
associate-*l*62.9%
add-cbrt-cube52.2%
pow1/340.8%
Applied egg-rr40.8%
unpow1/351.6%
rem-cbrt-cube62.4%
unpow262.4%
unpow262.4%
difference-of-squares63.5%
*-commutative63.5%
metadata-eval63.5%
div-inv64.0%
2-sin64.0%
associate-*l*73.4%
2-sin73.4%
div-inv72.9%
metadata-eval72.9%
Applied egg-rr72.9%
associate-*r*72.9%
*-commutative72.9%
metadata-eval72.9%
div-inv73.4%
associate-*r/71.4%
associate-*l/71.5%
sin-271.4%
associate-*l/72.3%
associate-*r/71.0%
add-cube-cbrt70.5%
pow370.5%
Applied egg-rr70.9%
Taylor expanded in b around 0 55.5%
mul-1-neg55.5%
*-commutative55.5%
distribute-rgt-neg-in55.5%
Simplified55.5%
if 2.39999999999999984e-62 < b Initial program 44.9%
associate-*l*44.9%
*-commutative44.9%
associate-*l*44.9%
Simplified44.9%
associate-*r*44.9%
*-commutative44.9%
associate-*l*44.9%
add-cbrt-cube39.1%
pow1/326.1%
Applied egg-rr26.1%
unpow1/341.6%
rem-cbrt-cube47.5%
unpow247.5%
unpow247.5%
difference-of-squares57.5%
*-commutative57.5%
metadata-eval57.5%
div-inv53.5%
2-sin53.5%
associate-*l*66.8%
2-sin66.8%
div-inv70.8%
metadata-eval70.8%
Applied egg-rr70.8%
Taylor expanded in angle around 0 70.3%
Final simplification59.5%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b_m angle_m) :precision binary64 (* angle_s (* (+ b_m a_m) (* (- b_m a_m) (sin (* PI (* (* angle_m 0.005555555555555556) 2.0)))))))
a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
return angle_s * ((b_m + a_m) * ((b_m - a_m) * sin((((double) M_PI) * ((angle_m * 0.005555555555555556) * 2.0)))));
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
return angle_s * ((b_m + a_m) * ((b_m - a_m) * Math.sin((Math.PI * ((angle_m * 0.005555555555555556) * 2.0)))));
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): return angle_s * ((b_m + a_m) * ((b_m - a_m) * math.sin((math.pi * ((angle_m * 0.005555555555555556) * 2.0)))))
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) return Float64(angle_s * Float64(Float64(b_m + a_m) * Float64(Float64(b_m - a_m) * sin(Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * 2.0)))))) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b_m, angle_m) tmp = angle_s * ((b_m + a_m) * ((b_m - a_m) * sin((pi * ((angle_m * 0.005555555555555556) * 2.0))))); end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[Sin[N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b\_m + a\_m\right) \cdot \left(\left(b\_m - a\_m\right) \cdot \sin \left(\pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot 2\right)\right)\right)\right)
\end{array}
Initial program 58.0%
associate-*l*58.0%
*-commutative58.0%
associate-*l*58.0%
Simplified58.0%
associate-*r*58.0%
*-commutative58.0%
associate-*l*58.0%
add-cbrt-cube48.6%
pow1/336.8%
Applied egg-rr36.8%
unpow1/348.9%
rem-cbrt-cube58.3%
unpow258.3%
unpow258.3%
difference-of-squares61.8%
*-commutative61.8%
metadata-eval61.8%
div-inv61.1%
2-sin61.1%
associate-*l*71.6%
2-sin71.6%
div-inv72.3%
metadata-eval72.3%
Applied egg-rr72.3%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(let* ((t_0 (* 0.011111111111111112 (* angle_m PI))))
(*
angle_s
(if (<= angle_m 3.7e+192)
(* (+ b_m a_m) (* 0.011111111111111112 (* angle_m (* (- b_m a_m) PI))))
(if (<= angle_m 4.6e+200)
(* 0.011111111111111112 (* (* angle_m a_m) (* b_m PI)))
(if (<= angle_m 2e+263)
(* t_0 (* a_m (- (- a_m) b_m)))
(* t_0 (* b_m a_m))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * ((double) M_PI));
double tmp;
if (angle_m <= 3.7e+192) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * ((double) M_PI))));
} else if (angle_m <= 4.6e+200) {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * ((double) M_PI)));
} else if (angle_m <= 2e+263) {
tmp = t_0 * (a_m * (-a_m - b_m));
} else {
tmp = t_0 * (b_m * a_m);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * Math.PI);
double tmp;
if (angle_m <= 3.7e+192) {
tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * Math.PI)));
} else if (angle_m <= 4.6e+200) {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * Math.PI));
} else if (angle_m <= 2e+263) {
tmp = t_0 * (a_m * (-a_m - b_m));
} else {
tmp = t_0 * (b_m * a_m);
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): t_0 = 0.011111111111111112 * (angle_m * math.pi) tmp = 0 if angle_m <= 3.7e+192: tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * math.pi))) elif angle_m <= 4.6e+200: tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * math.pi)) elif angle_m <= 2e+263: tmp = t_0 * (a_m * (-a_m - b_m)) else: tmp = t_0 * (b_m * a_m) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) t_0 = Float64(0.011111111111111112 * Float64(angle_m * pi)) tmp = 0.0 if (angle_m <= 3.7e+192) tmp = Float64(Float64(b_m + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); elseif (angle_m <= 4.6e+200) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * a_m) * Float64(b_m * pi))); elseif (angle_m <= 2e+263) tmp = Float64(t_0 * Float64(a_m * Float64(Float64(-a_m) - b_m))); else tmp = Float64(t_0 * Float64(b_m * a_m)); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) t_0 = 0.011111111111111112 * (angle_m * pi); tmp = 0.0; if (angle_m <= 3.7e+192) tmp = (b_m + a_m) * (0.011111111111111112 * (angle_m * ((b_m - a_m) * pi))); elseif (angle_m <= 4.6e+200) tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * pi)); elseif (angle_m <= 2e+263) tmp = t_0 * (a_m * (-a_m - b_m)); else tmp = t_0 * (b_m * a_m); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := Block[{t$95$0 = N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 3.7e+192], N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 4.6e+200], N[(0.011111111111111112 * N[(N[(angle$95$m * a$95$m), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 2e+263], N[(t$95$0 * N[(a$95$m * N[((-a$95$m) - b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(b$95$m * a$95$m), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := 0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 3.7 \cdot 10^{+192}:\\
\;\;\;\;\left(b\_m + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 4.6 \cdot 10^{+200}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot a\_m\right) \cdot \left(b\_m \cdot \pi\right)\right)\\
\mathbf{elif}\;angle\_m \leq 2 \cdot 10^{+263}:\\
\;\;\;\;t\_0 \cdot \left(a\_m \cdot \left(\left(-a\_m\right) - b\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(b\_m \cdot a\_m\right)\\
\end{array}
\end{array}
\end{array}
if angle < 3.7000000000000001e192Initial program 60.4%
associate-*l*60.4%
*-commutative60.4%
associate-*l*60.4%
Simplified60.4%
associate-*r*60.4%
*-commutative60.4%
associate-*l*60.4%
add-cbrt-cube49.5%
pow1/334.5%
Applied egg-rr34.6%
unpow1/349.9%
rem-cbrt-cube60.8%
unpow260.8%
unpow260.8%
difference-of-squares63.9%
*-commutative63.9%
metadata-eval63.9%
div-inv63.5%
2-sin63.5%
associate-*l*75.5%
2-sin75.5%
div-inv75.9%
metadata-eval75.9%
Applied egg-rr75.9%
Taylor expanded in angle around 0 70.0%
if 3.7000000000000001e192 < angle < 4.60000000000000006e200Initial program 33.6%
associate-*l*33.6%
*-commutative33.6%
associate-*l*33.6%
Simplified33.6%
unpow233.6%
unpow233.6%
difference-of-squares33.6%
Applied egg-rr33.6%
Taylor expanded in angle around 0 0.2%
Taylor expanded in b around 0 0.2%
Taylor expanded in a around 0 35.1%
associate-*r*50.2%
Simplified50.2%
if 4.60000000000000006e200 < angle < 2.00000000000000003e263Initial program 39.8%
associate-*l*39.8%
*-commutative39.8%
associate-*l*39.8%
Simplified39.8%
unpow239.8%
unpow239.8%
difference-of-squares39.8%
Applied egg-rr39.8%
Taylor expanded in angle around 0 37.5%
Taylor expanded in b around 0 38.6%
neg-mul-138.6%
Simplified38.6%
if 2.00000000000000003e263 < angle Initial program 45.0%
associate-*l*45.0%
*-commutative45.0%
associate-*l*45.0%
Simplified45.0%
unpow245.0%
unpow245.0%
difference-of-squares51.6%
Applied egg-rr51.6%
Taylor expanded in angle around 0 29.3%
Taylor expanded in b around 0 28.5%
Taylor expanded in a around 0 36.9%
Final simplification66.2%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(let* ((t_0 (* 0.011111111111111112 (* angle_m PI))))
(*
angle_s
(if (<= angle_m 3.7e+192)
(* 0.011111111111111112 (* a_m (* angle_m (* (- b_m a_m) PI))))
(if (<= angle_m 5.1e+200)
(* 0.011111111111111112 (* (* angle_m a_m) (* b_m PI)))
(if (<= angle_m 1.9e+260)
(* t_0 (* a_m (- a_m)))
(* t_0 (* b_m a_m))))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * ((double) M_PI));
double tmp;
if (angle_m <= 3.7e+192) {
tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * ((double) M_PI))));
} else if (angle_m <= 5.1e+200) {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * ((double) M_PI)));
} else if (angle_m <= 1.9e+260) {
tmp = t_0 * (a_m * -a_m);
} else {
tmp = t_0 * (b_m * a_m);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * Math.PI);
double tmp;
if (angle_m <= 3.7e+192) {
tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * Math.PI)));
} else if (angle_m <= 5.1e+200) {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * Math.PI));
} else if (angle_m <= 1.9e+260) {
tmp = t_0 * (a_m * -a_m);
} else {
tmp = t_0 * (b_m * a_m);
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): t_0 = 0.011111111111111112 * (angle_m * math.pi) tmp = 0 if angle_m <= 3.7e+192: tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * math.pi))) elif angle_m <= 5.1e+200: tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * math.pi)) elif angle_m <= 1.9e+260: tmp = t_0 * (a_m * -a_m) else: tmp = t_0 * (b_m * a_m) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) t_0 = Float64(0.011111111111111112 * Float64(angle_m * pi)) tmp = 0.0 if (angle_m <= 3.7e+192) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); elseif (angle_m <= 5.1e+200) tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * a_m) * Float64(b_m * pi))); elseif (angle_m <= 1.9e+260) tmp = Float64(t_0 * Float64(a_m * Float64(-a_m))); else tmp = Float64(t_0 * Float64(b_m * a_m)); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) t_0 = 0.011111111111111112 * (angle_m * pi); tmp = 0.0; if (angle_m <= 3.7e+192) tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * pi))); elseif (angle_m <= 5.1e+200) tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * pi)); elseif (angle_m <= 1.9e+260) tmp = t_0 * (a_m * -a_m); else tmp = t_0 * (b_m * a_m); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := Block[{t$95$0 = N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 3.7e+192], N[(0.011111111111111112 * N[(a$95$m * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 5.1e+200], N[(0.011111111111111112 * N[(N[(angle$95$m * a$95$m), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 1.9e+260], N[(t$95$0 * N[(a$95$m * (-a$95$m)), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(b$95$m * a$95$m), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := 0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 3.7 \cdot 10^{+192}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 5.1 \cdot 10^{+200}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot a\_m\right) \cdot \left(b\_m \cdot \pi\right)\right)\\
\mathbf{elif}\;angle\_m \leq 1.9 \cdot 10^{+260}:\\
\;\;\;\;t\_0 \cdot \left(a\_m \cdot \left(-a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(b\_m \cdot a\_m\right)\\
\end{array}
\end{array}
\end{array}
if angle < 3.7000000000000001e192Initial program 60.4%
associate-*l*60.4%
*-commutative60.4%
associate-*l*60.4%
Simplified60.4%
unpow260.4%
unpow260.4%
difference-of-squares63.5%
Applied egg-rr63.5%
Taylor expanded in angle around 0 59.6%
Taylor expanded in b around 0 44.6%
Taylor expanded in angle around 0 50.8%
if 3.7000000000000001e192 < angle < 5.0999999999999999e200Initial program 33.6%
associate-*l*33.6%
*-commutative33.6%
associate-*l*33.6%
Simplified33.6%
unpow233.6%
unpow233.6%
difference-of-squares33.6%
Applied egg-rr33.6%
Taylor expanded in angle around 0 0.2%
Taylor expanded in b around 0 0.2%
Taylor expanded in a around 0 35.1%
associate-*r*50.2%
Simplified50.2%
if 5.0999999999999999e200 < angle < 1.8999999999999999e260Initial program 39.8%
associate-*l*39.8%
*-commutative39.8%
associate-*l*39.8%
Simplified39.8%
unpow239.8%
unpow239.8%
difference-of-squares39.8%
Applied egg-rr39.8%
Taylor expanded in angle around 0 37.5%
Taylor expanded in b around 0 38.2%
Taylor expanded in b around 0 38.9%
neg-mul-138.6%
Simplified38.9%
if 1.8999999999999999e260 < angle Initial program 45.0%
associate-*l*45.0%
*-commutative45.0%
associate-*l*45.0%
Simplified45.0%
unpow245.0%
unpow245.0%
difference-of-squares51.6%
Applied egg-rr51.6%
Taylor expanded in angle around 0 29.3%
Taylor expanded in b around 0 28.5%
Taylor expanded in a around 0 36.9%
Final simplification49.5%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(let* ((t_0 (* 0.011111111111111112 (* angle_m PI))))
(*
angle_s
(if (<= a_m 1.32e+154)
(* (* (+ b_m a_m) (- b_m a_m)) t_0)
(* a_m (* (- b_m a_m) t_0))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * ((double) M_PI));
double tmp;
if (a_m <= 1.32e+154) {
tmp = ((b_m + a_m) * (b_m - a_m)) * t_0;
} else {
tmp = a_m * ((b_m - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double t_0 = 0.011111111111111112 * (angle_m * Math.PI);
double tmp;
if (a_m <= 1.32e+154) {
tmp = ((b_m + a_m) * (b_m - a_m)) * t_0;
} else {
tmp = a_m * ((b_m - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): t_0 = 0.011111111111111112 * (angle_m * math.pi) tmp = 0 if a_m <= 1.32e+154: tmp = ((b_m + a_m) * (b_m - a_m)) * t_0 else: tmp = a_m * ((b_m - a_m) * t_0) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) t_0 = Float64(0.011111111111111112 * Float64(angle_m * pi)) tmp = 0.0 if (a_m <= 1.32e+154) tmp = Float64(Float64(Float64(b_m + a_m) * Float64(b_m - a_m)) * t_0); else tmp = Float64(a_m * Float64(Float64(b_m - a_m) * t_0)); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) t_0 = 0.011111111111111112 * (angle_m * pi); tmp = 0.0; if (a_m <= 1.32e+154) tmp = ((b_m + a_m) * (b_m - a_m)) * t_0; else tmp = a_m * ((b_m - a_m) * t_0); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := Block[{t$95$0 = N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[a$95$m, 1.32e+154], N[(N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], N[(a$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := 0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 1.32 \cdot 10^{+154}:\\
\;\;\;\;\left(\left(b\_m + a\_m\right) \cdot \left(b\_m - a\_m\right)\right) \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;a\_m \cdot \left(\left(b\_m - a\_m\right) \cdot t\_0\right)\\
\end{array}
\end{array}
\end{array}
if a < 1.31999999999999998e154Initial program 60.3%
associate-*l*60.3%
*-commutative60.3%
associate-*l*60.3%
Simplified60.3%
unpow260.3%
unpow260.3%
difference-of-squares61.7%
Applied egg-rr61.7%
Taylor expanded in angle around 0 56.1%
if 1.31999999999999998e154 < a Initial program 42.6%
associate-*l*42.6%
*-commutative42.6%
associate-*l*42.6%
Simplified42.6%
unpow242.6%
unpow242.6%
difference-of-squares57.3%
Applied egg-rr57.3%
Taylor expanded in angle around 0 51.5%
Taylor expanded in b around 0 48.5%
pow148.5%
Applied egg-rr48.5%
unpow148.5%
associate-*l*70.5%
Simplified70.5%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 4.6e+153)
(* 0.011111111111111112 (* angle_m (* PI (* (+ b_m a_m) (- b_m a_m)))))
(* a_m (* (- b_m a_m) (* 0.011111111111111112 (* angle_m PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 4.6e+153) {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b_m + a_m) * (b_m - a_m))));
} else {
tmp = a_m * ((b_m - a_m) * (0.011111111111111112 * (angle_m * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 4.6e+153) {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b_m + a_m) * (b_m - a_m))));
} else {
tmp = a_m * ((b_m - a_m) * (0.011111111111111112 * (angle_m * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if a_m <= 4.6e+153: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b_m + a_m) * (b_m - a_m)))) else: tmp = a_m * ((b_m - a_m) * (0.011111111111111112 * (angle_m * math.pi))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (a_m <= 4.6e+153) tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b_m + a_m) * Float64(b_m - a_m))))); else tmp = Float64(a_m * Float64(Float64(b_m - a_m) * Float64(0.011111111111111112 * Float64(angle_m * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (a_m <= 4.6e+153) tmp = 0.011111111111111112 * (angle_m * (pi * ((b_m + a_m) * (b_m - a_m)))); else tmp = a_m * ((b_m - a_m) * (0.011111111111111112 * (angle_m * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 4.6e+153], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b$95$m + a$95$m), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 4.6 \cdot 10^{+153}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b\_m + a\_m\right) \cdot \left(b\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;a\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if a < 4.6000000000000003e153Initial program 60.3%
associate-*l*60.3%
*-commutative60.3%
associate-*l*60.3%
Simplified60.3%
unpow260.3%
unpow260.3%
difference-of-squares61.7%
Applied egg-rr61.7%
Taylor expanded in angle around 0 56.1%
Taylor expanded in angle around 0 56.0%
if 4.6000000000000003e153 < a Initial program 42.6%
associate-*l*42.6%
*-commutative42.6%
associate-*l*42.6%
Simplified42.6%
unpow242.6%
unpow242.6%
difference-of-squares57.3%
Applied egg-rr57.3%
Taylor expanded in angle around 0 51.5%
Taylor expanded in b around 0 48.5%
pow148.5%
Applied egg-rr48.5%
unpow148.5%
associate-*l*70.5%
Simplified70.5%
Final simplification57.9%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 4.7e-39)
(* (* 0.011111111111111112 (* angle_m PI)) (* b_m (- b_m a_m)))
(* 0.011111111111111112 (* a_m (* angle_m (* (- b_m a_m) PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 4.7e-39) {
tmp = (0.011111111111111112 * (angle_m * ((double) M_PI))) * (b_m * (b_m - a_m));
} else {
tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 4.7e-39) {
tmp = (0.011111111111111112 * (angle_m * Math.PI)) * (b_m * (b_m - a_m));
} else {
tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if a_m <= 4.7e-39: tmp = (0.011111111111111112 * (angle_m * math.pi)) * (b_m * (b_m - a_m)) else: tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * math.pi))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (a_m <= 4.7e-39) tmp = Float64(Float64(0.011111111111111112 * Float64(angle_m * pi)) * Float64(b_m * Float64(b_m - a_m))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(angle_m * Float64(Float64(b_m - a_m) * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (a_m <= 4.7e-39) tmp = (0.011111111111111112 * (angle_m * pi)) * (b_m * (b_m - a_m)); else tmp = 0.011111111111111112 * (a_m * (angle_m * ((b_m - a_m) * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 4.7e-39], N[(N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision] * N[(b$95$m * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(angle$95$m * N[(N[(b$95$m - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 4.7 \cdot 10^{-39}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b\_m \cdot \left(b\_m - a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(angle\_m \cdot \left(\left(b\_m - a\_m\right) \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if a < 4.7000000000000002e-39Initial program 60.8%
associate-*l*60.8%
*-commutative60.8%
associate-*l*60.8%
Simplified60.8%
unpow260.8%
unpow260.8%
difference-of-squares62.5%
Applied egg-rr62.5%
Taylor expanded in angle around 0 56.4%
Taylor expanded in b around inf 43.5%
if 4.7000000000000002e-39 < a Initial program 51.4%
associate-*l*51.4%
*-commutative51.4%
associate-*l*51.4%
Simplified51.4%
unpow251.4%
unpow251.4%
difference-of-squares57.8%
Applied egg-rr57.8%
Taylor expanded in angle around 0 53.4%
Taylor expanded in b around 0 48.2%
Taylor expanded in angle around 0 56.6%
Final simplification47.5%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= b_m 1.4e+139)
(* (* 0.011111111111111112 (* angle_m PI)) (* a_m (- a_m)))
(* 0.011111111111111112 (* a_m (* angle_m (* b_m PI)))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 1.4e+139) {
tmp = (0.011111111111111112 * (angle_m * ((double) M_PI))) * (a_m * -a_m);
} else {
tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (b_m <= 1.4e+139) {
tmp = (0.011111111111111112 * (angle_m * Math.PI)) * (a_m * -a_m);
} else {
tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if b_m <= 1.4e+139: tmp = (0.011111111111111112 * (angle_m * math.pi)) * (a_m * -a_m) else: tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * math.pi))) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (b_m <= 1.4e+139) tmp = Float64(Float64(0.011111111111111112 * Float64(angle_m * pi)) * Float64(a_m * Float64(-a_m))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(angle_m * Float64(b_m * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (b_m <= 1.4e+139) tmp = (0.011111111111111112 * (angle_m * pi)) * (a_m * -a_m); else tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b$95$m, 1.4e+139], N[(N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision] * N[(a$95$m * (-a$95$m)), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(angle$95$m * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b\_m \leq 1.4 \cdot 10^{+139}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(a\_m \cdot \left(-a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(angle\_m \cdot \left(b\_m \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.3999999999999999e139Initial program 62.4%
associate-*l*62.4%
*-commutative62.4%
associate-*l*62.4%
Simplified62.4%
unpow262.4%
unpow262.4%
difference-of-squares63.3%
Applied egg-rr63.3%
Taylor expanded in angle around 0 55.0%
Taylor expanded in b around 0 42.9%
Taylor expanded in b around 0 41.4%
neg-mul-142.8%
Simplified41.4%
if 1.3999999999999999e139 < b Initial program 29.9%
associate-*l*29.9%
*-commutative29.9%
associate-*l*29.9%
Simplified29.9%
unpow229.9%
unpow229.9%
difference-of-squares47.0%
Applied egg-rr47.0%
Taylor expanded in angle around 0 58.7%
Taylor expanded in b around 0 38.8%
Taylor expanded in a around 0 38.5%
Final simplification41.0%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 2e+156)
(* (* 0.011111111111111112 (* angle_m PI)) (* b_m a_m))
(* 0.011111111111111112 (* (* angle_m a_m) (* b_m PI))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 2e+156) {
tmp = (0.011111111111111112 * (angle_m * ((double) M_PI))) * (b_m * a_m);
} else {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * ((double) M_PI)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 2e+156) {
tmp = (0.011111111111111112 * (angle_m * Math.PI)) * (b_m * a_m);
} else {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * Math.PI));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if a_m <= 2e+156: tmp = (0.011111111111111112 * (angle_m * math.pi)) * (b_m * a_m) else: tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * math.pi)) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (a_m <= 2e+156) tmp = Float64(Float64(0.011111111111111112 * Float64(angle_m * pi)) * Float64(b_m * a_m)); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * a_m) * Float64(b_m * pi))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (a_m <= 2e+156) tmp = (0.011111111111111112 * (angle_m * pi)) * (b_m * a_m); else tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * pi)); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 2e+156], N[(N[(0.011111111111111112 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision] * N[(b$95$m * a$95$m), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle$95$m * a$95$m), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 2 \cdot 10^{+156}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left(angle\_m \cdot \pi\right)\right) \cdot \left(b\_m \cdot a\_m\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot a\_m\right) \cdot \left(b\_m \cdot \pi\right)\right)\\
\end{array}
\end{array}
if a < 2e156Initial program 60.5%
associate-*l*60.5%
*-commutative60.5%
associate-*l*60.5%
Simplified60.5%
unpow260.5%
unpow260.5%
difference-of-squares61.9%
Applied egg-rr61.9%
Taylor expanded in angle around 0 55.8%
Taylor expanded in b around 0 41.2%
Taylor expanded in a around 0 26.7%
if 2e156 < a Initial program 40.9%
associate-*l*40.9%
*-commutative40.9%
associate-*l*40.9%
Simplified40.9%
unpow240.9%
unpow240.9%
difference-of-squares56.1%
Applied egg-rr56.1%
Taylor expanded in angle around 0 53.0%
Taylor expanded in b around 0 50.0%
Taylor expanded in a around 0 19.4%
associate-*r*22.1%
Simplified22.1%
Final simplification26.1%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b_m angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 5.7e-182)
(* 0.011111111111111112 (* a_m (* angle_m (* b_m PI))))
(* 0.011111111111111112 (* (* angle_m a_m) (* b_m PI))))))a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 5.7e-182) {
tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * ((double) M_PI))));
} else {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * ((double) M_PI)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
double tmp;
if (a_m <= 5.7e-182) {
tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * Math.PI)));
} else {
tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * Math.PI));
}
return angle_s * tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): tmp = 0 if a_m <= 5.7e-182: tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * math.pi))) else: tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * math.pi)) return angle_s * tmp
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) tmp = 0.0 if (a_m <= 5.7e-182) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(angle_m * Float64(b_m * pi)))); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle_m * a_m) * Float64(b_m * pi))); end return Float64(angle_s * tmp) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b_m, angle_m) tmp = 0.0; if (a_m <= 5.7e-182) tmp = 0.011111111111111112 * (a_m * (angle_m * (b_m * pi))); else tmp = 0.011111111111111112 * ((angle_m * a_m) * (b_m * pi)); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 5.7e-182], N[(0.011111111111111112 * N[(a$95$m * N[(angle$95$m * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle$95$m * a$95$m), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 5.7 \cdot 10^{-182}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(angle\_m \cdot \left(b\_m \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle\_m \cdot a\_m\right) \cdot \left(b\_m \cdot \pi\right)\right)\\
\end{array}
\end{array}
if a < 5.6999999999999998e-182Initial program 59.3%
associate-*l*59.3%
*-commutative59.3%
associate-*l*59.3%
Simplified59.3%
unpow259.3%
unpow259.3%
difference-of-squares61.4%
Applied egg-rr61.4%
Taylor expanded in angle around 0 54.4%
Taylor expanded in b around 0 40.2%
Taylor expanded in a around 0 27.5%
if 5.6999999999999998e-182 < a Initial program 56.2%
associate-*l*56.2%
*-commutative56.2%
associate-*l*56.2%
Simplified56.2%
unpow256.2%
unpow256.2%
difference-of-squares60.8%
Applied egg-rr60.8%
Taylor expanded in angle around 0 56.9%
Taylor expanded in b around 0 45.2%
Taylor expanded in a around 0 18.5%
associate-*r*19.3%
Simplified19.3%
Final simplification24.0%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b_m angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* a_m (* angle_m (* b_m PI))))))
a_m = fabs(a);
b_m = fabs(b);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b_m, double angle_m) {
return angle_s * (0.011111111111111112 * (a_m * (angle_m * (b_m * ((double) M_PI)))));
}
a_m = Math.abs(a);
b_m = Math.abs(b);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b_m, double angle_m) {
return angle_s * (0.011111111111111112 * (a_m * (angle_m * (b_m * Math.PI))));
}
a_m = math.fabs(a) b_m = math.fabs(b) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b_m, angle_m): return angle_s * (0.011111111111111112 * (a_m * (angle_m * (b_m * math.pi))))
a_m = abs(a) b_m = abs(b) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b_m, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(a_m * Float64(angle_m * Float64(b_m * pi))))) end
a_m = abs(a); b_m = abs(b); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b_m, angle_m) tmp = angle_s * (0.011111111111111112 * (a_m * (angle_m * (b_m * pi)))); end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $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$95$m_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(a$95$m * N[(angle$95$m * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(a\_m \cdot \left(angle\_m \cdot \left(b\_m \cdot \pi\right)\right)\right)\right)
\end{array}
Initial program 58.0%
associate-*l*58.0%
*-commutative58.0%
associate-*l*58.0%
Simplified58.0%
unpow258.0%
unpow258.0%
difference-of-squares61.1%
Applied egg-rr61.1%
Taylor expanded in angle around 0 55.5%
Taylor expanded in b around 0 42.3%
Taylor expanded in a around 0 23.6%
herbie shell --seed 2024110
(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)))))