
(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 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.011111111111111112))))
(*
angle_s
(if (<= a_m 1.35e+163)
(* (+ b a_m) (* (- b a_m) (fabs (sin t_0))))
(if (<= a_m 1.2e+261)
(*
(+ b a_m)
(*
(- b a_m)
(*
angle_m
(+
(* -2.2862368541380886e-7 (* (pow angle_m 2.0) (pow PI 3.0)))
(* PI 0.011111111111111112)))))
(* (+ b a_m) (* (- b a_m) t_0)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.011111111111111112);
double tmp;
if (a_m <= 1.35e+163) {
tmp = (b + a_m) * ((b - a_m) * fabs(sin(t_0)));
} else if (a_m <= 1.2e+261) {
tmp = (b + a_m) * ((b - a_m) * (angle_m * ((-2.2862368541380886e-7 * (pow(angle_m, 2.0) * pow(((double) M_PI), 3.0))) + (((double) M_PI) * 0.011111111111111112))));
} else {
tmp = (b + a_m) * ((b - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.011111111111111112);
double tmp;
if (a_m <= 1.35e+163) {
tmp = (b + a_m) * ((b - a_m) * Math.abs(Math.sin(t_0)));
} else if (a_m <= 1.2e+261) {
tmp = (b + a_m) * ((b - a_m) * (angle_m * ((-2.2862368541380886e-7 * (Math.pow(angle_m, 2.0) * Math.pow(Math.PI, 3.0))) + (Math.PI * 0.011111111111111112))));
} else {
tmp = (b + a_m) * ((b - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi * (angle_m * 0.011111111111111112) tmp = 0 if a_m <= 1.35e+163: tmp = (b + a_m) * ((b - a_m) * math.fabs(math.sin(t_0))) elif a_m <= 1.2e+261: tmp = (b + a_m) * ((b - a_m) * (angle_m * ((-2.2862368541380886e-7 * (math.pow(angle_m, 2.0) * math.pow(math.pi, 3.0))) + (math.pi * 0.011111111111111112)))) else: tmp = (b + a_m) * ((b - a_m) * t_0) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.011111111111111112)) tmp = 0.0 if (a_m <= 1.35e+163) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * abs(sin(t_0)))); elseif (a_m <= 1.2e+261) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(angle_m * Float64(Float64(-2.2862368541380886e-7 * Float64((angle_m ^ 2.0) * (pi ^ 3.0))) + Float64(pi * 0.011111111111111112))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * t_0)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi * (angle_m * 0.011111111111111112); tmp = 0.0; if (a_m <= 1.35e+163) tmp = (b + a_m) * ((b - a_m) * abs(sin(t_0))); elseif (a_m <= 1.2e+261) tmp = (b + a_m) * ((b - a_m) * (angle_m * ((-2.2862368541380886e-7 * ((angle_m ^ 2.0) * (pi ^ 3.0))) + (pi * 0.011111111111111112)))); else tmp = (b + a_m) * ((b - a_m) * t_0); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[a$95$m, 1.35e+163], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Abs[N[Sin[t$95$0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 1.2e+261], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(angle$95$m * N[(N[(-2.2862368541380886e-7 * N[(N[Power[angle$95$m, 2.0], $MachinePrecision] * N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 1.35 \cdot 10^{+163}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left|\sin t\_0\right|\right)\\
\mathbf{elif}\;a\_m \leq 1.2 \cdot 10^{+261}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(angle\_m \cdot \left(-2.2862368541380886 \cdot 10^{-7} \cdot \left({angle\_m}^{2} \cdot {\pi}^{3}\right) + \pi \cdot 0.011111111111111112\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot t\_0\right)\\
\end{array}
\end{array}
\end{array}
if a < 1.35e163Initial program 55.1%
associate-*l*55.1%
*-commutative55.1%
associate-*l*55.1%
Simplified55.1%
unpow255.1%
unpow255.1%
difference-of-squares56.4%
Applied egg-rr56.4%
pow156.4%
associate-*l*64.7%
2-sin64.7%
div-inv65.0%
metadata-eval65.0%
Applied egg-rr65.0%
unpow165.0%
+-commutative65.0%
associate-*r*65.2%
*-commutative65.2%
*-commutative65.2%
Simplified65.2%
*-commutative65.2%
*-commutative65.2%
associate-*r*65.0%
add-sqr-sqrt29.6%
sqrt-unprod34.9%
pow234.9%
Applied egg-rr34.9%
unpow234.9%
rem-sqrt-square41.7%
*-commutative41.7%
associate-*r*41.7%
Simplified41.7%
if 1.35e163 < a < 1.1999999999999999e261Initial program 27.9%
associate-*l*27.9%
*-commutative27.9%
associate-*l*27.9%
Simplified27.9%
unpow227.9%
unpow227.9%
difference-of-squares42.3%
Applied egg-rr42.3%
pow142.3%
associate-*l*66.3%
2-sin66.3%
div-inv72.9%
metadata-eval72.9%
Applied egg-rr72.9%
unpow172.9%
+-commutative72.9%
associate-*r*73.0%
*-commutative73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in angle around 0 86.4%
if 1.1999999999999999e261 < a Initial program 42.9%
associate-*l*42.9%
*-commutative42.9%
associate-*l*42.9%
Simplified42.9%
unpow242.9%
unpow242.9%
difference-of-squares57.1%
Applied egg-rr57.1%
pow157.1%
associate-*l*57.1%
2-sin57.1%
div-inv42.9%
metadata-eval42.9%
Applied egg-rr42.9%
unpow142.9%
+-commutative42.9%
associate-*r*57.1%
*-commutative57.1%
*-commutative57.1%
Simplified57.1%
Taylor expanded in angle around 0 85.7%
associate-*r*85.7%
Simplified85.7%
Final simplification45.5%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= b 1.35e+216)
(*
(+ b a_m)
(*
(- b a_m)
(sin
(*
2.0
(*
0.005555555555555556
(* angle_m (* (cbrt PI) (pow (cbrt PI) 2.0))))))))
(*
(+ b a_m)
(*
(- b a_m)
(sin
(* 2.0 (expm1 (log1p (* 0.005555555555555556 (* angle_m PI)))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 1.35e+216) {
tmp = (b + a_m) * ((b - a_m) * sin((2.0 * (0.005555555555555556 * (angle_m * (cbrt(((double) M_PI)) * pow(cbrt(((double) M_PI)), 2.0)))))));
} else {
tmp = (b + a_m) * ((b - a_m) * sin((2.0 * expm1(log1p((0.005555555555555556 * (angle_m * ((double) M_PI))))))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 1.35e+216) {
tmp = (b + a_m) * ((b - a_m) * Math.sin((2.0 * (0.005555555555555556 * (angle_m * (Math.cbrt(Math.PI) * Math.pow(Math.cbrt(Math.PI), 2.0)))))));
} else {
tmp = (b + a_m) * ((b - a_m) * Math.sin((2.0 * Math.expm1(Math.log1p((0.005555555555555556 * (angle_m * Math.PI)))))));
}
return angle_s * tmp;
}
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (b <= 1.35e+216) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * sin(Float64(2.0 * Float64(0.005555555555555556 * Float64(angle_m * Float64(cbrt(pi) * (cbrt(pi) ^ 2.0)))))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * sin(Float64(2.0 * expm1(log1p(Float64(0.005555555555555556 * Float64(angle_m * pi)))))))); end return Float64(angle_s * tmp) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b, 1.35e+216], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(2.0 * N[(0.005555555555555556 * N[(angle$95$m * N[(N[Power[Pi, 1/3], $MachinePrecision] * N[Power[N[Power[Pi, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(2.0 * N[(Exp[N[Log[1 + N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b \leq 1.35 \cdot 10^{+216}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(2 \cdot \left(0.005555555555555556 \cdot \left(angle\_m \cdot \left(\sqrt[3]{\pi} \cdot {\left(\sqrt[3]{\pi}\right)}^{2}\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.3500000000000001e216Initial program 53.7%
associate-*l*53.7%
*-commutative53.7%
associate-*l*53.7%
Simplified53.7%
unpow253.7%
unpow253.7%
difference-of-squares55.1%
Applied egg-rr55.1%
pow155.1%
associate-*l*63.9%
2-sin63.9%
div-inv63.7%
metadata-eval63.7%
Applied egg-rr63.7%
unpow163.7%
+-commutative63.7%
associate-*r*64.4%
*-commutative64.4%
*-commutative64.4%
Simplified64.4%
add-cube-cbrt69.9%
pow269.9%
Applied egg-rr69.9%
if 1.3500000000000001e216 < b Initial program 44.6%
associate-*l*44.6%
*-commutative44.6%
associate-*l*44.6%
Simplified44.6%
unpow244.6%
unpow244.6%
difference-of-squares63.4%
Applied egg-rr63.4%
pow163.4%
associate-*l*74.9%
2-sin74.9%
div-inv81.2%
metadata-eval81.2%
Applied egg-rr81.2%
unpow181.2%
+-commutative81.2%
associate-*r*81.3%
*-commutative81.3%
*-commutative81.3%
Simplified81.3%
expm1-log1p-u75.0%
expm1-undefine13.5%
Applied egg-rr13.5%
expm1-define75.0%
*-commutative75.0%
Simplified75.0%
Final simplification70.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= b 2400.0)
(*
(+ b a_m)
(*
(- b a_m)
(sin (* 2.0 (* 0.005555555555555556 (* angle_m (pow (sqrt PI) 2.0)))))))
(*
(+ b a_m)
(* (- b a_m) (fabs (sin (* PI (* angle_m 0.011111111111111112)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 2400.0) {
tmp = (b + a_m) * ((b - a_m) * sin((2.0 * (0.005555555555555556 * (angle_m * pow(sqrt(((double) M_PI)), 2.0))))));
} else {
tmp = (b + a_m) * ((b - a_m) * fabs(sin((((double) M_PI) * (angle_m * 0.011111111111111112)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 2400.0) {
tmp = (b + a_m) * ((b - a_m) * Math.sin((2.0 * (0.005555555555555556 * (angle_m * Math.pow(Math.sqrt(Math.PI), 2.0))))));
} else {
tmp = (b + a_m) * ((b - a_m) * Math.abs(Math.sin((Math.PI * (angle_m * 0.011111111111111112)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if b <= 2400.0: tmp = (b + a_m) * ((b - a_m) * math.sin((2.0 * (0.005555555555555556 * (angle_m * math.pow(math.sqrt(math.pi), 2.0)))))) else: tmp = (b + a_m) * ((b - a_m) * math.fabs(math.sin((math.pi * (angle_m * 0.011111111111111112))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (b <= 2400.0) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * sin(Float64(2.0 * Float64(0.005555555555555556 * Float64(angle_m * (sqrt(pi) ^ 2.0))))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * abs(sin(Float64(pi * Float64(angle_m * 0.011111111111111112)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (b <= 2400.0) tmp = (b + a_m) * ((b - a_m) * sin((2.0 * (0.005555555555555556 * (angle_m * (sqrt(pi) ^ 2.0)))))); else tmp = (b + a_m) * ((b - a_m) * abs(sin((pi * (angle_m * 0.011111111111111112))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b, 2400.0], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(2.0 * N[(0.005555555555555556 * N[(angle$95$m * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Abs[N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b \leq 2400:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(2 \cdot \left(0.005555555555555556 \cdot \left(angle\_m \cdot {\left(\sqrt{\pi}\right)}^{2}\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left|\sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right)\right|\right)\\
\end{array}
\end{array}
if b < 2400Initial program 55.9%
associate-*l*55.9%
*-commutative55.9%
associate-*l*55.9%
Simplified55.9%
unpow255.9%
unpow255.9%
difference-of-squares57.5%
Applied egg-rr57.5%
pow157.5%
associate-*l*63.6%
2-sin63.6%
div-inv62.9%
metadata-eval62.9%
Applied egg-rr62.9%
unpow162.9%
+-commutative62.9%
associate-*r*63.2%
*-commutative63.2%
*-commutative63.2%
Simplified63.2%
add-sqr-sqrt68.2%
pow268.2%
Applied egg-rr68.2%
if 2400 < b Initial program 44.0%
associate-*l*44.0%
*-commutative44.0%
associate-*l*44.0%
Simplified44.0%
unpow244.0%
unpow244.0%
difference-of-squares49.5%
Applied egg-rr49.5%
pow149.5%
associate-*l*68.0%
2-sin68.0%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
unpow171.1%
+-commutative71.1%
associate-*r*72.8%
*-commutative72.8%
*-commutative72.8%
Simplified72.8%
*-commutative72.8%
*-commutative72.8%
associate-*r*71.1%
add-sqr-sqrt31.4%
sqrt-unprod28.1%
pow228.1%
Applied egg-rr28.1%
unpow228.1%
rem-sqrt-square36.0%
*-commutative36.0%
associate-*r*36.0%
Simplified36.0%
Final simplification60.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(*
(+ b a_m)
(*
(- b a_m)
(sin (* 2.0 (expm1 (log1p (* 0.005555555555555556 (* angle_m PI))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((b - a_m) * sin((2.0 * expm1(log1p((0.005555555555555556 * (angle_m * ((double) M_PI)))))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((b - a_m) * Math.sin((2.0 * Math.expm1(Math.log1p((0.005555555555555556 * (angle_m * Math.PI))))))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b + a_m) * ((b - a_m) * math.sin((2.0 * math.expm1(math.log1p((0.005555555555555556 * (angle_m * math.pi))))))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * sin(Float64(2.0 * expm1(log1p(Float64(0.005555555555555556 * Float64(angle_m * pi))))))))) end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(2.0 * N[(Exp[N[Log[1 + N[(0.005555555555555556 * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(0.005555555555555556 \cdot \left(angle\_m \cdot \pi\right)\right)\right)\right)\right)\right)
\end{array}
Initial program 53.1%
associate-*l*53.1%
*-commutative53.1%
associate-*l*53.1%
Simplified53.1%
unpow253.1%
unpow253.1%
difference-of-squares55.6%
Applied egg-rr55.6%
pow155.6%
associate-*l*64.6%
2-sin64.6%
div-inv64.8%
metadata-eval64.8%
Applied egg-rr64.8%
unpow164.8%
+-commutative64.8%
associate-*r*65.4%
*-commutative65.4%
*-commutative65.4%
Simplified65.4%
expm1-log1p-u58.3%
expm1-undefine19.9%
Applied egg-rr19.9%
expm1-define58.3%
*-commutative58.3%
Simplified58.3%
Final simplification58.3%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (pow b 2.0) 2000000000.0)
(* (+ b a_m) (* (- b a_m) (sin (* 2.0 (/ PI (/ 180.0 angle_m))))))
(* (+ b a_m) (* 0.011111111111111112 (* angle_m (* (- b a_m) PI)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (pow(b, 2.0) <= 2000000000.0) {
tmp = (b + a_m) * ((b - a_m) * sin((2.0 * (((double) M_PI) / (180.0 / angle_m)))));
} else {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (Math.pow(b, 2.0) <= 2000000000.0) {
tmp = (b + a_m) * ((b - a_m) * Math.sin((2.0 * (Math.PI / (180.0 / angle_m)))));
} else {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if math.pow(b, 2.0) <= 2000000000.0: tmp = (b + a_m) * ((b - a_m) * math.sin((2.0 * (math.pi / (180.0 / angle_m))))) else: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * math.pi))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if ((b ^ 2.0) <= 2000000000.0) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * sin(Float64(2.0 * Float64(pi / Float64(180.0 / angle_m)))))); else tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b - a_m) * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((b ^ 2.0) <= 2000000000.0) tmp = (b + a_m) * ((b - a_m) * sin((2.0 * (pi / (180.0 / angle_m))))); else tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 2000000000.0], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(2.0 * N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 2000000000:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(2 \cdot \frac{\pi}{\frac{180}{angle\_m}}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b - a\_m\right) \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 2e9Initial program 59.4%
associate-*l*59.4%
*-commutative59.4%
associate-*l*59.4%
Simplified59.4%
unpow259.4%
unpow259.4%
difference-of-squares59.4%
Applied egg-rr59.4%
pow159.4%
associate-*l*63.0%
2-sin63.0%
div-inv61.9%
metadata-eval61.9%
Applied egg-rr61.9%
unpow161.9%
+-commutative61.9%
associate-*r*61.7%
*-commutative61.7%
*-commutative61.7%
Simplified61.7%
*-commutative61.7%
*-commutative61.7%
associate-*r*61.9%
metadata-eval61.9%
div-inv63.0%
clear-num62.7%
un-div-inv63.7%
Applied egg-rr63.7%
if 2e9 < (pow.f64 b #s(literal 2 binary64)) Initial program 46.9%
associate-*l*46.9%
*-commutative46.9%
associate-*l*46.9%
Simplified46.9%
unpow246.9%
unpow246.9%
difference-of-squares51.9%
Applied egg-rr51.9%
pow151.9%
associate-*l*66.2%
2-sin66.2%
div-inv67.8%
metadata-eval67.8%
Applied egg-rr67.8%
unpow167.8%
+-commutative67.8%
associate-*r*69.1%
*-commutative69.1%
*-commutative69.1%
Simplified69.1%
Taylor expanded in angle around 0 74.1%
Final simplification68.9%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.011111111111111112))))
(*
angle_s
(if (<= (pow b 2.0) 5e+110)
(* (- b a_m) (* (+ b a_m) (sin t_0)))
(* (+ b a_m) (* (- b a_m) t_0))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.011111111111111112);
double tmp;
if (pow(b, 2.0) <= 5e+110) {
tmp = (b - a_m) * ((b + a_m) * sin(t_0));
} else {
tmp = (b + a_m) * ((b - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.011111111111111112);
double tmp;
if (Math.pow(b, 2.0) <= 5e+110) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(t_0));
} else {
tmp = (b + a_m) * ((b - a_m) * t_0);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi * (angle_m * 0.011111111111111112) tmp = 0 if math.pow(b, 2.0) <= 5e+110: tmp = (b - a_m) * ((b + a_m) * math.sin(t_0)) else: tmp = (b + a_m) * ((b - a_m) * t_0) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.011111111111111112)) tmp = 0.0 if ((b ^ 2.0) <= 5e+110) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(t_0))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * t_0)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi * (angle_m * 0.011111111111111112); tmp = 0.0; if ((b ^ 2.0) <= 5e+110) tmp = (b - a_m) * ((b + a_m) * sin(t_0)); else tmp = (b + a_m) * ((b - a_m) * t_0); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 5e+110], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 5 \cdot 10^{+110}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \sin t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot t\_0\right)\\
\end{array}
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 4.99999999999999978e110Initial program 58.7%
associate-*l*58.7%
*-commutative58.7%
associate-*l*58.7%
Simplified58.7%
unpow258.7%
unpow258.7%
difference-of-squares58.7%
Applied egg-rr58.7%
add-exp-log37.5%
associate-*l*39.1%
2-sin39.1%
div-inv38.5%
metadata-eval38.5%
Applied egg-rr38.5%
Taylor expanded in angle around inf 58.4%
*-commutative58.4%
+-commutative58.4%
*-commutative58.4%
associate-*r*63.2%
*-commutative63.2%
associate-*r*63.2%
+-commutative63.2%
*-commutative63.2%
associate-*r*63.2%
Simplified63.2%
if 4.99999999999999978e110 < (pow.f64 b #s(literal 2 binary64)) Initial program 44.9%
associate-*l*44.9%
*-commutative44.9%
associate-*l*44.9%
Simplified44.9%
unpow244.9%
unpow244.9%
difference-of-squares51.1%
Applied egg-rr51.1%
pow151.1%
associate-*l*66.2%
2-sin66.2%
div-inv67.2%
metadata-eval67.2%
Applied egg-rr67.2%
unpow167.2%
+-commutative67.2%
associate-*r*68.7%
*-commutative68.7%
*-commutative68.7%
Simplified68.7%
Taylor expanded in angle around 0 75.3%
associate-*r*75.4%
Simplified75.4%
Final simplification68.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (pow b 2.0) 1e-202)
(* (+ b a_m) (* (sin (* PI (* angle_m 0.011111111111111112))) (- a_m)))
(* (+ b a_m) (* 0.011111111111111112 (* angle_m (* (- b a_m) PI)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (pow(b, 2.0) <= 1e-202) {
tmp = (b + a_m) * (sin((((double) M_PI) * (angle_m * 0.011111111111111112))) * -a_m);
} else {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * ((double) M_PI))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (Math.pow(b, 2.0) <= 1e-202) {
tmp = (b + a_m) * (Math.sin((Math.PI * (angle_m * 0.011111111111111112))) * -a_m);
} else {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * Math.PI)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if math.pow(b, 2.0) <= 1e-202: tmp = (b + a_m) * (math.sin((math.pi * (angle_m * 0.011111111111111112))) * -a_m) else: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * math.pi))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if ((b ^ 2.0) <= 1e-202) tmp = Float64(Float64(b + a_m) * Float64(sin(Float64(pi * Float64(angle_m * 0.011111111111111112))) * Float64(-a_m))); else tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b - a_m) * pi)))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((b ^ 2.0) <= 1e-202) tmp = (b + a_m) * (sin((pi * (angle_m * 0.011111111111111112))) * -a_m); else tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * pi))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 1e-202], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-a$95$m)), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 10^{-202}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right) \cdot \left(-a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b - a\_m\right) \cdot \pi\right)\right)\right)\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 1e-202Initial program 61.8%
associate-*l*61.8%
*-commutative61.8%
associate-*l*61.8%
Simplified61.8%
unpow261.8%
unpow261.8%
difference-of-squares61.8%
Applied egg-rr61.8%
pow161.8%
associate-*l*63.9%
2-sin63.9%
div-inv63.4%
metadata-eval63.4%
Applied egg-rr63.4%
unpow163.4%
+-commutative63.4%
associate-*r*63.7%
*-commutative63.7%
*-commutative63.7%
Simplified63.7%
Taylor expanded in b around 0 63.5%
associate-*r*63.5%
neg-mul-163.5%
*-commutative63.5%
*-commutative63.5%
*-commutative63.5%
associate-*r*63.1%
Simplified63.1%
if 1e-202 < (pow.f64 b #s(literal 2 binary64)) Initial program 48.6%
associate-*l*48.6%
*-commutative48.6%
associate-*l*48.6%
Simplified48.6%
unpow248.6%
unpow248.6%
difference-of-squares52.4%
Applied egg-rr52.4%
pow152.4%
associate-*l*65.0%
2-sin65.0%
div-inv65.6%
metadata-eval65.6%
Applied egg-rr65.6%
unpow165.6%
+-commutative65.6%
associate-*r*66.3%
*-commutative66.3%
*-commutative66.3%
Simplified66.3%
Taylor expanded in angle around 0 69.3%
Final simplification67.2%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (+ b a_m) (* (- b a_m) (fabs (sin (* PI (* angle_m 0.011111111111111112))))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((b - a_m) * fabs(sin((((double) M_PI) * (angle_m * 0.011111111111111112))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((b - a_m) * Math.abs(Math.sin((Math.PI * (angle_m * 0.011111111111111112))))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b + a_m) * ((b - a_m) * math.fabs(math.sin((math.pi * (angle_m * 0.011111111111111112))))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * abs(sin(Float64(pi * Float64(angle_m * 0.011111111111111112))))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((b + a_m) * ((b - a_m) * abs(sin((pi * (angle_m * 0.011111111111111112)))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Abs[N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left|\sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right)\right|\right)\right)
\end{array}
Initial program 53.1%
associate-*l*53.1%
*-commutative53.1%
associate-*l*53.1%
Simplified53.1%
unpow253.1%
unpow253.1%
difference-of-squares55.6%
Applied egg-rr55.6%
pow155.6%
associate-*l*64.6%
2-sin64.6%
div-inv64.8%
metadata-eval64.8%
Applied egg-rr64.8%
unpow164.8%
+-commutative64.8%
associate-*r*65.4%
*-commutative65.4%
*-commutative65.4%
Simplified65.4%
*-commutative65.4%
*-commutative65.4%
associate-*r*64.8%
add-sqr-sqrt30.2%
sqrt-unprod34.7%
pow234.7%
Applied egg-rr34.6%
unpow234.6%
rem-sqrt-square42.0%
*-commutative42.0%
associate-*r*42.0%
Simplified42.0%
Final simplification42.0%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 3.3e+14)
(* (+ b a_m) (* 0.011111111111111112 (* angle_m (* (- b a_m) PI))))
(if (<= angle_m 1.35e+45)
(* (+ b a_m) (* b (sin (* (* angle_m PI) 0.011111111111111112))))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 3.3e+14) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * ((double) M_PI))));
} else if (angle_m <= 1.35e+45) {
tmp = (b + a_m) * (b * sin(((angle_m * ((double) M_PI)) * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 3.3e+14) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * Math.PI)));
} else if (angle_m <= 1.35e+45) {
tmp = (b + a_m) * (b * Math.sin(((angle_m * Math.PI) * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 3.3e+14: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * math.pi))) elif angle_m <= 1.35e+45: tmp = (b + a_m) * (b * math.sin(((angle_m * math.pi) * 0.011111111111111112))) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 3.3e+14) tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b - a_m) * pi)))); elseif (angle_m <= 1.35e+45) tmp = Float64(Float64(b + a_m) * Float64(b * sin(Float64(Float64(angle_m * pi) * 0.011111111111111112)))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 3.3e+14) tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * pi))); elseif (angle_m <= 1.35e+45) tmp = (b + a_m) * (b * sin(((angle_m * pi) * 0.011111111111111112))); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 3.3e+14], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 1.35e+45], N[(N[(b + a$95$m), $MachinePrecision] * N[(b * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 3.3 \cdot 10^{+14}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 1.35 \cdot 10^{+45}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(b \cdot \sin \left(\left(angle\_m \cdot \pi\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 3.3e14Initial program 60.3%
associate-*l*60.3%
*-commutative60.3%
associate-*l*60.3%
Simplified60.3%
unpow260.3%
unpow260.3%
difference-of-squares62.9%
Applied egg-rr62.9%
pow162.9%
associate-*l*74.2%
2-sin74.2%
div-inv74.8%
metadata-eval74.8%
Applied egg-rr74.8%
unpow174.8%
+-commutative74.8%
associate-*r*74.9%
*-commutative74.9%
*-commutative74.9%
Simplified74.9%
Taylor expanded in angle around 0 75.0%
if 3.3e14 < angle < 1.34999999999999992e45Initial program 35.9%
associate-*l*35.9%
*-commutative35.9%
associate-*l*35.9%
Simplified35.9%
unpow235.9%
unpow235.9%
difference-of-squares35.9%
Applied egg-rr35.9%
pow135.9%
associate-*l*35.9%
2-sin35.9%
div-inv33.3%
metadata-eval33.3%
Applied egg-rr33.3%
unpow133.3%
+-commutative33.3%
associate-*r*44.4%
*-commutative44.4%
*-commutative44.4%
Simplified44.4%
Taylor expanded in b around inf 37.6%
if 1.34999999999999992e45 < angle Initial program 23.7%
associate-*l*23.7%
*-commutative23.7%
associate-*l*23.7%
Simplified23.7%
Taylor expanded in angle around 0 24.9%
unpow223.7%
unpow223.7%
difference-of-squares25.9%
Applied egg-rr27.2%
Final simplification65.4%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1.5e+45)
(* (- b a_m) (* (+ b a_m) (sin (* (* angle_m PI) 0.011111111111111112))))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.5e+45) {
tmp = (b - a_m) * ((b + a_m) * sin(((angle_m * ((double) M_PI)) * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.5e+45) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(((angle_m * Math.PI) * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 1.5e+45: tmp = (b - a_m) * ((b + a_m) * math.sin(((angle_m * math.pi) * 0.011111111111111112))) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 1.5e+45) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(Float64(Float64(angle_m * pi) * 0.011111111111111112)))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 1.5e+45) tmp = (b - a_m) * ((b + a_m) * sin(((angle_m * pi) * 0.011111111111111112))); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1.5e+45], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.5 \cdot 10^{+45}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \sin \left(\left(angle\_m \cdot \pi\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 1.50000000000000005e45Initial program 59.2%
associate-*l*59.2%
*-commutative59.2%
associate-*l*59.2%
Simplified59.2%
unpow259.2%
unpow259.2%
difference-of-squares61.8%
Applied egg-rr61.8%
add-exp-log34.7%
associate-*l*40.2%
2-sin40.2%
div-inv40.7%
metadata-eval40.7%
Applied egg-rr40.7%
rem-exp-log73.0%
associate-*r*62.1%
*-commutative62.1%
associate-*l*73.0%
associate-*r*73.6%
*-commutative73.6%
*-commutative73.6%
count-273.6%
associate-*r*72.7%
*-commutative72.7%
metadata-eval72.7%
div-inv72.7%
*-commutative72.7%
*-commutative72.7%
*-commutative72.7%
associate-*r*72.7%
rem-cbrt-cube72.8%
metadata-eval72.8%
div-inv72.4%
Applied egg-rr73.6%
if 1.50000000000000005e45 < angle Initial program 23.7%
associate-*l*23.7%
*-commutative23.7%
associate-*l*23.7%
Simplified23.7%
Taylor expanded in angle around 0 24.9%
unpow223.7%
unpow223.7%
difference-of-squares25.9%
Applied egg-rr27.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 7.2e-60)
(* (+ b a_m) (* 0.011111111111111112 (* (- b a_m) (* angle_m PI))))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 7.2e-60) {
tmp = (b + a_m) * (0.011111111111111112 * ((b - a_m) * (angle_m * ((double) M_PI))));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 7.2e-60) {
tmp = (b + a_m) * (0.011111111111111112 * ((b - a_m) * (angle_m * Math.PI)));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 7.2e-60: tmp = (b + a_m) * (0.011111111111111112 * ((b - a_m) * (angle_m * math.pi))) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 7.2e-60) tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(Float64(b - a_m) * Float64(angle_m * pi)))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 7.2e-60) tmp = (b + a_m) * (0.011111111111111112 * ((b - a_m) * (angle_m * pi))); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 7.2e-60], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(N[(b - a$95$m), $MachinePrecision] * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 7.2 \cdot 10^{-60}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(\left(b - a\_m\right) \cdot \left(angle\_m \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 7.2e-60Initial program 58.0%
associate-*l*58.0%
*-commutative58.0%
associate-*l*58.0%
Simplified58.0%
unpow258.0%
unpow258.0%
difference-of-squares59.3%
Applied egg-rr59.3%
pow159.3%
associate-*l*71.8%
2-sin71.8%
div-inv72.3%
metadata-eval72.3%
Applied egg-rr72.3%
unpow172.3%
+-commutative72.3%
associate-*r*72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Taylor expanded in angle around 0 73.2%
associate-*r*73.2%
Simplified73.2%
if 7.2e-60 < angle Initial program 40.7%
associate-*l*40.7%
*-commutative40.7%
associate-*l*40.7%
Simplified40.7%
Taylor expanded in angle around 0 35.6%
unpow240.7%
unpow240.7%
difference-of-squares46.2%
Applied egg-rr41.1%
Final simplification64.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 6.6e-60)
(* (+ b a_m) (* 0.011111111111111112 (* angle_m (* (- b a_m) PI))))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 6.6e-60) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * ((double) M_PI))));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 6.6e-60) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * Math.PI)));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 6.6e-60: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * math.pi))) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 6.6e-60) tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(b - a_m) * pi)))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 6.6e-60) tmp = (b + a_m) * (0.011111111111111112 * (angle_m * ((b - a_m) * pi))); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 6.6e-60], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(N[(b - a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 6.6 \cdot 10^{-60}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(b - a\_m\right) \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 6.5999999999999996e-60Initial program 58.0%
associate-*l*58.0%
*-commutative58.0%
associate-*l*58.0%
Simplified58.0%
unpow258.0%
unpow258.0%
difference-of-squares59.3%
Applied egg-rr59.3%
pow159.3%
associate-*l*71.8%
2-sin71.8%
div-inv72.3%
metadata-eval72.3%
Applied egg-rr72.3%
unpow172.3%
+-commutative72.3%
associate-*r*72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Taylor expanded in angle around 0 73.2%
if 6.5999999999999996e-60 < angle Initial program 40.7%
associate-*l*40.7%
*-commutative40.7%
associate-*l*40.7%
Simplified40.7%
Taylor expanded in angle around 0 35.6%
unpow240.7%
unpow240.7%
difference-of-squares46.2%
Applied egg-rr41.1%
Final simplification64.2%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1.9e-43)
(* 0.011111111111111112 (* (+ b a_m) (* PI (* (- b a_m) angle_m))))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.9e-43) {
tmp = 0.011111111111111112 * ((b + a_m) * (((double) M_PI) * ((b - a_m) * angle_m)));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.9e-43) {
tmp = 0.011111111111111112 * ((b + a_m) * (Math.PI * ((b - a_m) * angle_m)));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 1.9e-43: tmp = 0.011111111111111112 * ((b + a_m) * (math.pi * ((b - a_m) * angle_m))) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 1.9e-43) tmp = Float64(0.011111111111111112 * Float64(Float64(b + a_m) * Float64(pi * Float64(Float64(b - a_m) * angle_m)))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 1.9e-43) tmp = 0.011111111111111112 * ((b + a_m) * (pi * ((b - a_m) * angle_m))); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1.9e-43], N[(0.011111111111111112 * N[(N[(b + a$95$m), $MachinePrecision] * N[(Pi * N[(N[(b - a$95$m), $MachinePrecision] * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.9 \cdot 10^{-43}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(b + a\_m\right) \cdot \left(\pi \cdot \left(\left(b - a\_m\right) \cdot angle\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 1.89999999999999985e-43Initial program 59.0%
associate-*l*59.0%
*-commutative59.0%
associate-*l*59.0%
Simplified59.0%
Taylor expanded in angle around 0 60.8%
unpow259.0%
unpow259.0%
difference-of-squares60.8%
Applied egg-rr63.6%
Taylor expanded in angle around 0 63.6%
associate-*r*63.6%
+-commutative63.6%
*-commutative63.6%
+-commutative63.6%
Simplified63.6%
associate-*r*73.7%
+-commutative73.7%
distribute-lft-in68.4%
*-commutative68.4%
associate-*l*68.4%
*-commutative68.4%
associate-*l*68.4%
Applied egg-rr68.4%
+-commutative68.4%
distribute-lft-out73.8%
Simplified73.8%
if 1.89999999999999985e-43 < angle Initial program 35.8%
associate-*l*35.8%
*-commutative35.8%
associate-*l*35.8%
Simplified35.8%
Taylor expanded in angle around 0 30.2%
unpow235.8%
unpow235.8%
difference-of-squares40.4%
Applied egg-rr34.8%
Final simplification63.9%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 4e-58)
(* 0.011111111111111112 (* (* (- b a_m) angle_m) (* (+ b a_m) PI)))
(* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 4e-58) {
tmp = 0.011111111111111112 * (((b - a_m) * angle_m) * ((b + a_m) * ((double) M_PI)));
} else {
tmp = 0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 4e-58) {
tmp = 0.011111111111111112 * (((b - a_m) * angle_m) * ((b + a_m) * Math.PI));
} else {
tmp = 0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 4e-58: tmp = 0.011111111111111112 * (((b - a_m) * angle_m) * ((b + a_m) * math.pi)) else: tmp = 0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 4e-58) tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(b - a_m) * angle_m) * Float64(Float64(b + a_m) * pi))); else tmp = Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 4e-58) tmp = 0.011111111111111112 * (((b - a_m) * angle_m) * ((b + a_m) * pi)); else tmp = 0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 4e-58], N[(0.011111111111111112 * N[(N[(N[(b - a$95$m), $MachinePrecision] * angle$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 4 \cdot 10^{-58}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(b - a\_m\right) \cdot angle\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 4.0000000000000001e-58Initial program 58.0%
associate-*l*58.0%
*-commutative58.0%
associate-*l*58.0%
Simplified58.0%
Taylor expanded in angle around 0 59.9%
unpow258.0%
unpow258.0%
difference-of-squares59.3%
Applied egg-rr62.2%
Taylor expanded in angle around 0 62.2%
associate-*r*62.2%
+-commutative62.2%
*-commutative62.2%
+-commutative62.2%
Simplified62.2%
associate-*r*72.7%
+-commutative72.7%
distribute-lft-in68.3%
*-commutative68.3%
associate-*l*68.3%
*-commutative68.3%
associate-*l*68.3%
Applied egg-rr68.3%
distribute-lft-out72.8%
distribute-rgt-out68.3%
associate-*r*68.2%
associate-*r*68.3%
distribute-rgt-out72.8%
distribute-rgt-in72.8%
+-commutative72.8%
Simplified72.8%
if 4.0000000000000001e-58 < angle Initial program 40.7%
associate-*l*40.7%
*-commutative40.7%
associate-*l*40.7%
Simplified40.7%
Taylor expanded in angle around 0 35.6%
unpow240.7%
unpow240.7%
difference-of-squares46.2%
Applied egg-rr41.1%
Final simplification63.9%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* 0.011111111111111112 (* angle_m (* PI (* (+ b a_m) (- b a_m)))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * (angle_m * (((double) M_PI) * ((b + a_m) * (b - a_m)))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (0.011111111111111112 * (angle_m * (Math.PI * ((b + a_m) * (b - a_m)))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (0.011111111111111112 * (angle_m * (math.pi * ((b + a_m) * (b - a_m)))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(Float64(b + a_m) * Float64(b - a_m)))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (0.011111111111111112 * (angle_m * (pi * ((b + a_m) * (b - a_m))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(N[(b + a$95$m), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b + a\_m\right) \cdot \left(b - a\_m\right)\right)\right)\right)\right)
\end{array}
Initial program 53.1%
associate-*l*53.1%
*-commutative53.1%
associate-*l*53.1%
Simplified53.1%
Taylor expanded in angle around 0 53.0%
unpow253.1%
unpow253.1%
difference-of-squares55.6%
Applied egg-rr56.3%
herbie shell --seed 2024103
(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)))))