
(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
(*
angle_s
(if (or (<= a_m 1.45e+164) (not (<= a_m 6.8e+261)))
(*
(+ b a_m)
(* (- b a_m) (fabs (sin (* PI (* angle_m 0.011111111111111112))))))
(*
(+ b a_m)
(*
(- b a_m)
(*
angle_m
(+
(* -2.2862368541380886e-7 (* (pow angle_m 2.0) (pow PI 3.0)))
(* PI 0.011111111111111112))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((a_m <= 1.45e+164) || !(a_m <= 6.8e+261)) {
tmp = (b + a_m) * ((b - a_m) * fabs(sin((((double) M_PI) * (angle_m * 0.011111111111111112)))));
} else {
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))));
}
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 ((a_m <= 1.45e+164) || !(a_m <= 6.8e+261)) {
tmp = (b + a_m) * ((b - a_m) * Math.abs(Math.sin((Math.PI * (angle_m * 0.011111111111111112)))));
} else {
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))));
}
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 (a_m <= 1.45e+164) or not (a_m <= 6.8e+261): tmp = (b + a_m) * ((b - a_m) * math.fabs(math.sin((math.pi * (angle_m * 0.011111111111111112))))) else: 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)))) 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 ((a_m <= 1.45e+164) || !(a_m <= 6.8e+261)) tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * abs(sin(Float64(pi * Float64(angle_m * 0.011111111111111112)))))); else 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))))); 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 ((a_m <= 1.45e+164) || ~((a_m <= 6.8e+261))) tmp = (b + a_m) * ((b - a_m) * abs(sin((pi * (angle_m * 0.011111111111111112))))); else tmp = (b + a_m) * ((b - a_m) * (angle_m * ((-2.2862368541380886e-7 * ((angle_m ^ 2.0) * (pi ^ 3.0))) + (pi * 0.011111111111111112)))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[Or[LessEqual[a$95$m, 1.45e+164], N[Not[LessEqual[a$95$m, 6.8e+261]], $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], 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]]), $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}\;a\_m \leq 1.45 \cdot 10^{+164} \lor \neg \left(a\_m \leq 6.8 \cdot 10^{+261}\right):\\
\;\;\;\;\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)\\
\mathbf{else}:\\
\;\;\;\;\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)\\
\end{array}
\end{array}
if a < 1.4499999999999999e164 or 6.8e261 < a Initial program 54.5%
associate-*l*54.5%
*-commutative54.5%
associate-*l*54.5%
Simplified54.5%
unpow254.5%
unpow254.5%
difference-of-squares56.3%
Applied egg-rr56.3%
pow156.3%
associate-*l*64.6%
2-sin64.6%
div-inv64.5%
metadata-eval64.5%
Applied egg-rr64.5%
unpow164.5%
+-commutative64.5%
associate-*r*65.1%
*-commutative65.1%
*-commutative65.1%
Simplified65.1%
*-commutative65.1%
*-commutative65.1%
associate-*r*64.5%
add-sqr-sqrt29.9%
sqrt-unprod35.0%
pow235.0%
Applied egg-rr35.0%
unpow235.0%
rem-sqrt-square42.0%
*-commutative42.0%
associate-*r*42.0%
Simplified42.0%
if 1.4499999999999999e164 < a < 6.8e261Initial program 29.9%
associate-*l*29.9%
*-commutative29.9%
associate-*l*29.9%
Simplified29.9%
unpow229.9%
unpow229.9%
difference-of-squares44.2%
Applied egg-rr44.2%
pow144.2%
associate-*l*64.0%
2-sin64.0%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
unpow171.1%
+-commutative71.1%
associate-*r*71.2%
*-commutative71.2%
*-commutative71.2%
Simplified71.2%
Taylor expanded in angle around 0 85.5%
Final simplification44.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 (<= 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) 1e+123)
(* (- 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) <= 1e+123) {
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) <= 1e+123) {
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) <= 1e+123: 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) <= 1e+123) 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) <= 1e+123) 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], 1e+123], 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 10^{+123}:\\
\;\;\;\;\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)) < 9.99999999999999978e122Initial program 59.2%
associate-*l*59.2%
*-commutative59.2%
associate-*l*59.2%
Simplified59.2%
unpow259.2%
unpow259.2%
difference-of-squares59.2%
Applied egg-rr59.2%
add-exp-log37.0%
associate-*l*38.6%
2-sin38.6%
div-inv38.0%
metadata-eval38.0%
Applied egg-rr38.0%
Taylor expanded in angle around inf 58.9%
*-commutative58.9%
+-commutative58.9%
*-commutative58.9%
associate-*r*63.7%
*-commutative63.7%
associate-*r*63.7%
+-commutative63.7%
*-commutative63.7%
associate-*r*63.7%
Simplified63.7%
if 9.99999999999999978e122 < (pow.f64 b #s(literal 2 binary64)) Initial program 43.8%
associate-*l*43.8%
*-commutative43.8%
associate-*l*43.8%
Simplified43.8%
unpow243.8%
unpow243.8%
difference-of-squares50.1%
Applied egg-rr50.1%
pow150.1%
associate-*l*65.5%
2-sin65.5%
div-inv66.6%
metadata-eval66.6%
Applied egg-rr66.6%
unpow166.6%
+-commutative66.6%
associate-*r*68.1%
*-commutative68.1%
*-commutative68.1%
Simplified68.1%
Taylor expanded in angle around 0 74.8%
associate-*r*74.9%
Simplified74.9%
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-201)
(* (+ b a_m) (* a_m (- (sin (* PI (* angle_m 0.011111111111111112))))))
(* (+ 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-201) {
tmp = (b + a_m) * (a_m * -sin((((double) M_PI) * (angle_m * 0.011111111111111112))));
} 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-201) {
tmp = (b + a_m) * (a_m * -Math.sin((Math.PI * (angle_m * 0.011111111111111112))));
} 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-201: tmp = (b + a_m) * (a_m * -math.sin((math.pi * (angle_m * 0.011111111111111112)))) 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-201) tmp = Float64(Float64(b + a_m) * Float64(a_m * Float64(-sin(Float64(pi * Float64(angle_m * 0.011111111111111112)))))); 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-201) tmp = (b + a_m) * (a_m * -sin((pi * (angle_m * 0.011111111111111112)))); 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-201], N[(N[(b + a$95$m), $MachinePrecision] * N[(a$95$m * (-N[Sin[N[(Pi * N[(angle$95$m * 0.011111111111111112), $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 10^{-201}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(a\_m \cdot \left(-\sin \left(\pi \cdot \left(angle\_m \cdot 0.011111111111111112\right)\right)\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)) < 9.99999999999999946e-202Initial program 62.2%
associate-*l*62.2%
*-commutative62.2%
associate-*l*62.2%
Simplified62.2%
unpow262.2%
unpow262.2%
difference-of-squares62.2%
Applied egg-rr62.2%
pow162.2%
associate-*l*64.3%
2-sin64.3%
div-inv63.8%
metadata-eval63.8%
Applied egg-rr63.8%
unpow163.8%
+-commutative63.8%
associate-*r*64.1%
*-commutative64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in b around 0 63.9%
associate-*r*63.9%
neg-mul-163.9%
*-commutative63.9%
*-commutative63.9%
*-commutative63.9%
associate-*r*63.5%
Simplified63.5%
if 9.99999999999999946e-202 < (pow.f64 b #s(literal 2 binary64)) Initial program 48.3%
associate-*l*48.3%
*-commutative48.3%
associate-*l*48.3%
Simplified48.3%
unpow248.3%
unpow248.3%
difference-of-squares52.1%
Applied egg-rr52.1%
pow152.1%
associate-*l*64.7%
2-sin64.8%
div-inv65.4%
metadata-eval65.4%
Applied egg-rr65.4%
unpow165.4%
+-commutative65.4%
associate-*r*66.1%
*-commutative66.1%
*-commutative66.1%
Simplified66.1%
Taylor expanded in angle around 0 69.2%
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
(let* ((t_0 (* (* angle_m PI) 0.011111111111111112)))
(*
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 t_0)))
(* t_0 (+ (* a_m (- b a_m)) (* b (- b a_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = (angle_m * ((double) M_PI)) * 0.011111111111111112;
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(t_0));
} else {
tmp = t_0 * ((a_m * (b - a_m)) + (b * (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 t_0 = (angle_m * Math.PI) * 0.011111111111111112;
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(t_0));
} else {
tmp = t_0 * ((a_m * (b - a_m)) + (b * (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): t_0 = (angle_m * math.pi) * 0.011111111111111112 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(t_0)) else: tmp = t_0 * ((a_m * (b - a_m)) + (b * (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) t_0 = Float64(Float64(angle_m * pi) * 0.011111111111111112) 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(t_0))); else tmp = Float64(t_0 * Float64(Float64(a_m * Float64(b - a_m)) + Float64(b * 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) t_0 = (angle_m * pi) * 0.011111111111111112; 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(t_0)); else tmp = t_0 * ((a_m * (b - a_m)) + (b * (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_] := Block[{t$95$0 = N[(N[(angle$95$m * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]}, 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[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(N[(a$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] + N[(b * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \left(angle\_m \cdot \pi\right) \cdot 0.011111111111111112\\
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 t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(a\_m \cdot \left(b - a\_m\right) + b \cdot \left(b - a\_m\right)\right)\\
\end{array}
\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%
Taylor expanded in angle around 0 27.2%
associate-*r*27.2%
+-commutative27.2%
*-commutative27.2%
+-commutative27.2%
Simplified27.2%
associate-*r*27.2%
metadata-eval27.2%
associate-*r*27.2%
*-commutative27.2%
*-commutative27.2%
associate-*r*27.2%
distribute-lft-in22.7%
distribute-lft-in20.1%
associate-*r*20.1%
*-commutative20.1%
*-commutative20.1%
associate-*r*20.1%
metadata-eval20.1%
associate-*r*20.1%
*-commutative20.1%
Applied egg-rr20.1%
distribute-lft-out22.7%
associate-*r*22.7%
Simplified22.7%
Final simplification64.7%
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 (* (* angle_m PI) 0.011111111111111112)))
(*
angle_s
(if (<= angle_m 1.5e+45)
(* (- b a_m) (* (+ b a_m) (sin t_0)))
(* t_0 (+ (* a_m (- b a_m)) (* b (- b a_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = (angle_m * ((double) M_PI)) * 0.011111111111111112;
double tmp;
if (angle_m <= 1.5e+45) {
tmp = (b - a_m) * ((b + a_m) * sin(t_0));
} else {
tmp = t_0 * ((a_m * (b - a_m)) + (b * (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 t_0 = (angle_m * Math.PI) * 0.011111111111111112;
double tmp;
if (angle_m <= 1.5e+45) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(t_0));
} else {
tmp = t_0 * ((a_m * (b - a_m)) + (b * (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): t_0 = (angle_m * math.pi) * 0.011111111111111112 tmp = 0 if angle_m <= 1.5e+45: tmp = (b - a_m) * ((b + a_m) * math.sin(t_0)) else: tmp = t_0 * ((a_m * (b - a_m)) + (b * (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) t_0 = Float64(Float64(angle_m * pi) * 0.011111111111111112) tmp = 0.0 if (angle_m <= 1.5e+45) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(t_0))); else tmp = Float64(t_0 * Float64(Float64(a_m * Float64(b - a_m)) + Float64(b * 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) t_0 = (angle_m * pi) * 0.011111111111111112; tmp = 0.0; if (angle_m <= 1.5e+45) tmp = (b - a_m) * ((b + a_m) * sin(t_0)); else tmp = t_0 * ((a_m * (b - a_m)) + (b * (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_] := Block[{t$95$0 = N[(N[(angle$95$m * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]}, 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[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(N[(a$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] + N[(b * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \left(angle\_m \cdot \pi\right) \cdot 0.011111111111111112\\
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 t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(a\_m \cdot \left(b - a\_m\right) + b \cdot \left(b - a\_m\right)\right)\\
\end{array}
\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%
Taylor expanded in angle around 0 27.2%
associate-*r*27.2%
+-commutative27.2%
*-commutative27.2%
+-commutative27.2%
Simplified27.2%
associate-*r*27.2%
metadata-eval27.2%
associate-*r*27.2%
*-commutative27.2%
*-commutative27.2%
associate-*r*27.2%
distribute-lft-in22.7%
distribute-lft-in20.1%
associate-*r*20.1%
*-commutative20.1%
*-commutative20.1%
associate-*r*20.1%
metadata-eval20.1%
associate-*r*20.1%
*-commutative20.1%
Applied egg-rr20.1%
distribute-lft-out22.7%
associate-*r*22.7%
Simplified22.7%
Final simplification64.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 2e-54)
(* (+ 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 <= 2e-54) {
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 <= 2e-54) {
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 <= 2e-54: 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 <= 2e-54) 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 <= 2e-54) 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, 2e-54], 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 2 \cdot 10^{-54}:\\
\;\;\;\;\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 < 2.0000000000000001e-54Initial program 58.5%
associate-*l*58.5%
*-commutative58.5%
associate-*l*58.5%
Simplified58.5%
unpow258.5%
unpow258.5%
difference-of-squares59.7%
Applied egg-rr59.7%
pow159.7%
associate-*l*72.1%
2-sin72.1%
div-inv72.6%
metadata-eval72.6%
Applied egg-rr72.6%
unpow172.6%
+-commutative72.6%
associate-*r*72.7%
*-commutative72.7%
*-commutative72.7%
Simplified72.7%
Taylor expanded in angle around 0 73.5%
associate-*r*73.5%
Simplified73.5%
if 2.0000000000000001e-54 < angle Initial program 39.0%
associate-*l*39.0%
*-commutative39.0%
associate-*l*39.0%
Simplified39.0%
Taylor expanded in angle around 0 33.7%
unpow239.0%
unpow239.0%
difference-of-squares44.7%
Applied egg-rr39.5%
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 8e-58)
(* (+ 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 <= 8e-58) {
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 <= 8e-58) {
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 <= 8e-58: 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 <= 8e-58) 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 <= 8e-58) 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, 8e-58], 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 8 \cdot 10^{-58}:\\
\;\;\;\;\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 < 8.0000000000000002e-58Initial 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 8.0000000000000002e-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 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 5e-33)
(* 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 <= 5e-33) {
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 <= 5e-33) {
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 <= 5e-33: 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 <= 5e-33) 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 <= 5e-33) 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, 5e-33], 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 5 \cdot 10^{-33}:\\
\;\;\;\;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 < 5.00000000000000028e-33Initial program 59.1%
associate-*l*59.2%
*-commutative59.2%
associate-*l*59.2%
Simplified59.2%
Taylor expanded in angle around 0 60.9%
unpow259.2%
unpow259.2%
difference-of-squares61.4%
Applied egg-rr64.2%
Taylor expanded in angle around 0 64.2%
associate-*r*64.1%
+-commutative64.1%
*-commutative64.1%
+-commutative64.1%
Simplified64.1%
associate-*r*74.1%
+-commutative74.1%
distribute-lft-in68.9%
*-commutative68.9%
associate-*l*68.9%
*-commutative68.9%
associate-*l*68.9%
Applied egg-rr68.9%
+-commutative68.9%
distribute-lft-out74.2%
Simplified74.2%
if 5.00000000000000028e-33 < angle Initial program 34.3%
associate-*l*34.3%
*-commutative34.3%
associate-*l*34.3%
Simplified34.3%
Taylor expanded in angle around 0 28.4%
unpow234.3%
unpow234.3%
difference-of-squares37.5%
Applied egg-rr31.7%
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 1.5e-57)
(* 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 <= 1.5e-57) {
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 <= 1.5e-57) {
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 <= 1.5e-57: 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 <= 1.5e-57) 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 <= 1.5e-57) 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, 1.5e-57], 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 1.5 \cdot 10^{-57}:\\
\;\;\;\;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 < 1.5e-57Initial 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 1.5e-57 < 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)))))