
(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 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(let* ((t_0 (* angle (* PI -0.005555555555555556))) (t_1 (sin t_0)))
(if (<= a_m 7e+140)
(*
(log1p (expm1 (cos t_0)))
(* 2.0 (- (* t_1 (pow a_m 2.0)) (* b_m (* t_1 b_m)))))
(if (<= a_m 2e+263)
(* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))
(*
2.0
(*
(* (pow a_m 2.0) (cos (* -0.005555555555555556 (* angle PI))))
(sin (* PI (* angle -0.005555555555555556)))))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double t_0 = angle * (((double) M_PI) * -0.005555555555555556);
double t_1 = sin(t_0);
double tmp;
if (a_m <= 7e+140) {
tmp = log1p(expm1(cos(t_0))) * (2.0 * ((t_1 * pow(a_m, 2.0)) - (b_m * (t_1 * b_m))));
} else if (a_m <= 2e+263) {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
} else {
tmp = 2.0 * ((pow(a_m, 2.0) * cos((-0.005555555555555556 * (angle * ((double) M_PI))))) * sin((((double) M_PI) * (angle * -0.005555555555555556))));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double t_0 = angle * (Math.PI * -0.005555555555555556);
double t_1 = Math.sin(t_0);
double tmp;
if (a_m <= 7e+140) {
tmp = Math.log1p(Math.expm1(Math.cos(t_0))) * (2.0 * ((t_1 * Math.pow(a_m, 2.0)) - (b_m * (t_1 * b_m))));
} else if (a_m <= 2e+263) {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
} else {
tmp = 2.0 * ((Math.pow(a_m, 2.0) * Math.cos((-0.005555555555555556 * (angle * Math.PI)))) * Math.sin((Math.PI * (angle * -0.005555555555555556))));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): t_0 = angle * (math.pi * -0.005555555555555556) t_1 = math.sin(t_0) tmp = 0 if a_m <= 7e+140: tmp = math.log1p(math.expm1(math.cos(t_0))) * (2.0 * ((t_1 * math.pow(a_m, 2.0)) - (b_m * (t_1 * b_m)))) elif a_m <= 2e+263: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) else: tmp = 2.0 * ((math.pow(a_m, 2.0) * math.cos((-0.005555555555555556 * (angle * math.pi)))) * math.sin((math.pi * (angle * -0.005555555555555556)))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) t_0 = Float64(angle * Float64(pi * -0.005555555555555556)) t_1 = sin(t_0) tmp = 0.0 if (a_m <= 7e+140) tmp = Float64(log1p(expm1(cos(t_0))) * Float64(2.0 * Float64(Float64(t_1 * (a_m ^ 2.0)) - Float64(b_m * Float64(t_1 * b_m))))); elseif (a_m <= 2e+263) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); else tmp = Float64(2.0 * Float64(Float64((a_m ^ 2.0) * cos(Float64(-0.005555555555555556 * Float64(angle * pi)))) * sin(Float64(pi * Float64(angle * -0.005555555555555556))))); end return tmp end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[t$95$0], $MachinePrecision]}, If[LessEqual[a$95$m, 7e+140], N[(N[Log[1 + N[(Exp[N[Cos[t$95$0], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[(t$95$1 * N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision] - N[(b$95$m * N[(t$95$1 * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 2e+263], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[Cos[N[(-0.005555555555555556 * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(Pi * N[(angle * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := angle \cdot \left(\pi \cdot -0.005555555555555556\right)\\
t_1 := \sin t\_0\\
\mathbf{if}\;a\_m \leq 7 \cdot 10^{+140}:\\
\;\;\;\;\mathsf{log1p}\left(\mathsf{expm1}\left(\cos t\_0\right)\right) \cdot \left(2 \cdot \left(t\_1 \cdot {a\_m}^{2} - b\_m \cdot \left(t\_1 \cdot b\_m\right)\right)\right)\\
\mathbf{elif}\;a\_m \leq 2 \cdot 10^{+263}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left({a\_m}^{2} \cdot \cos \left(-0.005555555555555556 \cdot \left(angle \cdot \pi\right)\right)\right) \cdot \sin \left(\pi \cdot \left(angle \cdot -0.005555555555555556\right)\right)\right)\\
\end{array}
\end{array}
if a < 6.99999999999999978e140Initial program 54.1%
Simplified53.8%
associate-*r/55.7%
Applied egg-rr55.7%
log1p-expm1-u55.7%
div-inv55.7%
metadata-eval55.7%
Applied egg-rr55.7%
unpow255.7%
unpow255.7%
difference-of-squares57.1%
Applied egg-rr57.1%
Taylor expanded in b around 0 62.0%
+-commutative62.0%
*-commutative62.0%
Simplified61.1%
if 6.99999999999999978e140 < a < 2.00000000000000003e263Initial program 27.7%
Taylor expanded in angle around 0 31.4%
unpow231.4%
unpow231.4%
difference-of-squares38.8%
Applied egg-rr38.8%
Taylor expanded in b around 0 38.8%
Taylor expanded in angle around 0 66.6%
associate-*r*66.7%
Simplified66.7%
if 2.00000000000000003e263 < a Initial program 63.6%
Simplified63.6%
Taylor expanded in a around inf 72.7%
associate-*r*72.7%
associate-*r*63.6%
associate-*r*63.6%
Simplified63.6%
Taylor expanded in a around 0 90.9%
Final simplification62.9%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(let* ((t_0 (- (pow b_m 2.0) (pow a_m 2.0)))
(t_1 (sin (* (* angle PI) -0.011111111111111112))))
(if (<= t_0 -5e+283)
(* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))
(if (<= t_0 -1e-280)
(* (pow a_m 2.0) t_1)
(if (<= t_0 2e+290)
(* (pow b_m 2.0) (- t_1))
(if (<= t_0 INFINITY)
(+
(* (* (pow a_m 2.0) (* angle PI)) -0.011111111111111112)
(*
b_m
(+
(* 0.011111111111111112 (* angle (* PI b_m)))
(* 0.011111111111111112 (* angle (* PI (- a_m a_m)))))))
(*
0.011111111111111112
(* angle (* PI (* (+ a_m b_m) (- a_m)))))))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double t_0 = pow(b_m, 2.0) - pow(a_m, 2.0);
double t_1 = sin(((angle * ((double) M_PI)) * -0.011111111111111112));
double tmp;
if (t_0 <= -5e+283) {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
} else if (t_0 <= -1e-280) {
tmp = pow(a_m, 2.0) * t_1;
} else if (t_0 <= 2e+290) {
tmp = pow(b_m, 2.0) * -t_1;
} else if (t_0 <= ((double) INFINITY)) {
tmp = ((pow(a_m, 2.0) * (angle * ((double) M_PI))) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (((double) M_PI) * b_m))) + (0.011111111111111112 * (angle * (((double) M_PI) * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * ((a_m + b_m) * -a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double t_0 = Math.pow(b_m, 2.0) - Math.pow(a_m, 2.0);
double t_1 = Math.sin(((angle * Math.PI) * -0.011111111111111112));
double tmp;
if (t_0 <= -5e+283) {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
} else if (t_0 <= -1e-280) {
tmp = Math.pow(a_m, 2.0) * t_1;
} else if (t_0 <= 2e+290) {
tmp = Math.pow(b_m, 2.0) * -t_1;
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = ((Math.pow(a_m, 2.0) * (angle * Math.PI)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (Math.PI * b_m))) + (0.011111111111111112 * (angle * (Math.PI * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (angle * (Math.PI * ((a_m + b_m) * -a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): t_0 = math.pow(b_m, 2.0) - math.pow(a_m, 2.0) t_1 = math.sin(((angle * math.pi) * -0.011111111111111112)) tmp = 0 if t_0 <= -5e+283: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) elif t_0 <= -1e-280: tmp = math.pow(a_m, 2.0) * t_1 elif t_0 <= 2e+290: tmp = math.pow(b_m, 2.0) * -t_1 elif t_0 <= math.inf: tmp = ((math.pow(a_m, 2.0) * (angle * math.pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (math.pi * b_m))) + (0.011111111111111112 * (angle * (math.pi * (a_m - a_m)))))) else: tmp = 0.011111111111111112 * (angle * (math.pi * ((a_m + b_m) * -a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) t_0 = Float64((b_m ^ 2.0) - (a_m ^ 2.0)) t_1 = sin(Float64(Float64(angle * pi) * -0.011111111111111112)) tmp = 0.0 if (t_0 <= -5e+283) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); elseif (t_0 <= -1e-280) tmp = Float64((a_m ^ 2.0) * t_1); elseif (t_0 <= 2e+290) tmp = Float64((b_m ^ 2.0) * Float64(-t_1)); elseif (t_0 <= Inf) tmp = Float64(Float64(Float64((a_m ^ 2.0) * Float64(angle * pi)) * -0.011111111111111112) + Float64(b_m * Float64(Float64(0.011111111111111112 * Float64(angle * Float64(pi * b_m))) + Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(a_m - a_m))))))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(Float64(a_m + b_m) * Float64(-a_m))))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) t_0 = (b_m ^ 2.0) - (a_m ^ 2.0); t_1 = sin(((angle * pi) * -0.011111111111111112)); tmp = 0.0; if (t_0 <= -5e+283) tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); elseif (t_0 <= -1e-280) tmp = (a_m ^ 2.0) * t_1; elseif (t_0 <= 2e+290) tmp = (b_m ^ 2.0) * -t_1; elseif (t_0 <= Inf) tmp = (((a_m ^ 2.0) * (angle * pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (pi * b_m))) + (0.011111111111111112 * (angle * (pi * (a_m - a_m)))))); else tmp = 0.011111111111111112 * (angle * (pi * ((a_m + b_m) * -a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(N[Power[b$95$m, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(N[(angle * Pi), $MachinePrecision] * -0.011111111111111112), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -5e+283], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -1e-280], N[(N[Power[a$95$m, 2.0], $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$0, 2e+290], N[(N[Power[b$95$m, 2.0], $MachinePrecision] * (-t$95$1)), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(N[(N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision] * -0.011111111111111112), $MachinePrecision] + N[(b$95$m * N[(N[(0.011111111111111112 * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.011111111111111112 * N[(angle * N[(Pi * N[(a$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(N[(a$95$m + b$95$m), $MachinePrecision] * (-a$95$m)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := {b\_m}^{2} - {a\_m}^{2}\\
t_1 := \sin \left(\left(angle \cdot \pi\right) \cdot -0.011111111111111112\right)\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{+283}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\mathbf{elif}\;t\_0 \leq -1 \cdot 10^{-280}:\\
\;\;\;\;{a\_m}^{2} \cdot t\_1\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+290}:\\
\;\;\;\;{b\_m}^{2} \cdot \left(-t\_1\right)\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;\left({a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right) \cdot -0.011111111111111112 + b\_m \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) + 0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(a\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(\left(a\_m + b\_m\right) \cdot \left(-a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < -5.0000000000000004e283Initial program 39.3%
Taylor expanded in angle around 0 39.6%
unpow239.6%
unpow239.6%
difference-of-squares39.6%
Applied egg-rr39.6%
Taylor expanded in b around 0 39.6%
Taylor expanded in angle around 0 63.9%
associate-*r*64.0%
Simplified64.0%
if -5.0000000000000004e283 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < -9.9999999999999996e-281Initial program 51.4%
Simplified51.1%
Applied egg-rr23.9%
Taylor expanded in a around inf 51.8%
if -9.9999999999999996e-281 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < 2.00000000000000012e290Initial program 67.9%
Simplified68.4%
Applied egg-rr47.5%
Taylor expanded in a around 0 68.5%
associate-*r*68.5%
neg-mul-168.5%
Simplified68.5%
if 2.00000000000000012e290 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < +inf.0Initial program 48.2%
Taylor expanded in angle around 0 37.7%
unpow237.7%
unpow237.7%
difference-of-squares37.7%
Applied egg-rr37.7%
Taylor expanded in b around 0 70.7%
if +inf.0 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in angle around 0 0.0%
unpow20.0%
unpow20.0%
difference-of-squares45.2%
Applied egg-rr45.2%
Taylor expanded in b around 0 45.2%
neg-mul-145.2%
Simplified45.2%
Final simplification63.4%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(let* ((t_0 (- (pow b_m 2.0) (pow a_m 2.0))))
(if (<= t_0 -5e+283)
(* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))
(if (<= t_0 2e+290)
(*
(cos (* -0.005555555555555556 (* angle PI)))
(* 2.0 (* (* (- a_m b_m) (+ a_m b_m)) (sin (* angle (/ PI -180.0))))))
(if (<= t_0 INFINITY)
(+
(* (* (pow a_m 2.0) (* angle PI)) -0.011111111111111112)
(*
b_m
(+
(* 0.011111111111111112 (* angle (* PI b_m)))
(* 0.011111111111111112 (* angle (* PI (- a_m a_m)))))))
(* 0.011111111111111112 (* angle (* PI (* (+ a_m b_m) (- a_m))))))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double t_0 = pow(b_m, 2.0) - pow(a_m, 2.0);
double tmp;
if (t_0 <= -5e+283) {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
} else if (t_0 <= 2e+290) {
tmp = cos((-0.005555555555555556 * (angle * ((double) M_PI)))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle * (((double) M_PI) / -180.0)))));
} else if (t_0 <= ((double) INFINITY)) {
tmp = ((pow(a_m, 2.0) * (angle * ((double) M_PI))) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (((double) M_PI) * b_m))) + (0.011111111111111112 * (angle * (((double) M_PI) * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * ((a_m + b_m) * -a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double t_0 = Math.pow(b_m, 2.0) - Math.pow(a_m, 2.0);
double tmp;
if (t_0 <= -5e+283) {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
} else if (t_0 <= 2e+290) {
tmp = Math.cos((-0.005555555555555556 * (angle * Math.PI))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * Math.sin((angle * (Math.PI / -180.0)))));
} else if (t_0 <= Double.POSITIVE_INFINITY) {
tmp = ((Math.pow(a_m, 2.0) * (angle * Math.PI)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (Math.PI * b_m))) + (0.011111111111111112 * (angle * (Math.PI * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (angle * (Math.PI * ((a_m + b_m) * -a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): t_0 = math.pow(b_m, 2.0) - math.pow(a_m, 2.0) tmp = 0 if t_0 <= -5e+283: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) elif t_0 <= 2e+290: tmp = math.cos((-0.005555555555555556 * (angle * math.pi))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * math.sin((angle * (math.pi / -180.0))))) elif t_0 <= math.inf: tmp = ((math.pow(a_m, 2.0) * (angle * math.pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (math.pi * b_m))) + (0.011111111111111112 * (angle * (math.pi * (a_m - a_m)))))) else: tmp = 0.011111111111111112 * (angle * (math.pi * ((a_m + b_m) * -a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) t_0 = Float64((b_m ^ 2.0) - (a_m ^ 2.0)) tmp = 0.0 if (t_0 <= -5e+283) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); elseif (t_0 <= 2e+290) tmp = Float64(cos(Float64(-0.005555555555555556 * Float64(angle * pi))) * Float64(2.0 * Float64(Float64(Float64(a_m - b_m) * Float64(a_m + b_m)) * sin(Float64(angle * Float64(pi / -180.0)))))); elseif (t_0 <= Inf) tmp = Float64(Float64(Float64((a_m ^ 2.0) * Float64(angle * pi)) * -0.011111111111111112) + Float64(b_m * Float64(Float64(0.011111111111111112 * Float64(angle * Float64(pi * b_m))) + Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(a_m - a_m))))))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(Float64(a_m + b_m) * Float64(-a_m))))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) t_0 = (b_m ^ 2.0) - (a_m ^ 2.0); tmp = 0.0; if (t_0 <= -5e+283) tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); elseif (t_0 <= 2e+290) tmp = cos((-0.005555555555555556 * (angle * pi))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle * (pi / -180.0))))); elseif (t_0 <= Inf) tmp = (((a_m ^ 2.0) * (angle * pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (pi * b_m))) + (0.011111111111111112 * (angle * (pi * (a_m - a_m)))))); else tmp = 0.011111111111111112 * (angle * (pi * ((a_m + b_m) * -a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(N[Power[b$95$m, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -5e+283], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2e+290], N[(N[Cos[N[(-0.005555555555555556 * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(angle * N[(Pi / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(N[(N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision] * -0.011111111111111112), $MachinePrecision] + N[(b$95$m * N[(N[(0.011111111111111112 * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.011111111111111112 * N[(angle * N[(Pi * N[(a$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(N[(a$95$m + b$95$m), $MachinePrecision] * (-a$95$m)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := {b\_m}^{2} - {a\_m}^{2}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{+283}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+290}:\\
\;\;\;\;\cos \left(-0.005555555555555556 \cdot \left(angle \cdot \pi\right)\right) \cdot \left(2 \cdot \left(\left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right) \cdot \sin \left(angle \cdot \frac{\pi}{-180}\right)\right)\right)\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;\left({a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right) \cdot -0.011111111111111112 + b\_m \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) + 0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(a\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(\left(a\_m + b\_m\right) \cdot \left(-a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < -5.0000000000000004e283Initial program 39.3%
Taylor expanded in angle around 0 39.6%
unpow239.6%
unpow239.6%
difference-of-squares39.6%
Applied egg-rr39.6%
Taylor expanded in b around 0 39.6%
Taylor expanded in angle around 0 63.9%
associate-*r*64.0%
Simplified64.0%
if -5.0000000000000004e283 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < 2.00000000000000012e290Initial program 61.4%
Simplified61.5%
unpow261.0%
unpow261.0%
difference-of-squares61.0%
Applied egg-rr61.5%
Taylor expanded in angle around inf 62.0%
if 2.00000000000000012e290 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < +inf.0Initial program 48.2%
Taylor expanded in angle around 0 37.7%
unpow237.7%
unpow237.7%
difference-of-squares37.7%
Applied egg-rr37.7%
Taylor expanded in b around 0 70.7%
if +inf.0 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in angle around 0 0.0%
unpow20.0%
unpow20.0%
difference-of-squares45.2%
Applied egg-rr45.2%
Taylor expanded in b around 0 45.2%
neg-mul-145.2%
Simplified45.2%
Final simplification63.5%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(let* ((t_0 (* (- a_m b_m) (+ a_m b_m)))
(t_1 (* angle (* PI -0.005555555555555556))))
(if (<= (/ angle 180.0) 1e-54)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(if (<= (/ angle 180.0) 2e+64)
(*
(cos (* angle (/ (cbrt (pow PI 3.0)) -180.0)))
(* 2.0 (* t_0 (sin (* angle (/ PI -180.0))))))
(if (<= (/ angle 180.0) 5e+255)
(*
(* 2.0 (* (sin (/ (* angle PI) -180.0)) t_0))
(cbrt (pow (cos t_1) 3.0)))
(* (* 2.0 (* (- b_m a_m) (+ a_m b_m))) (/ (sin (* t_1 2.0)) 2.0)))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double t_0 = (a_m - b_m) * (a_m + b_m);
double t_1 = angle * (((double) M_PI) * -0.005555555555555556);
double tmp;
if ((angle / 180.0) <= 1e-54) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else if ((angle / 180.0) <= 2e+64) {
tmp = cos((angle * (cbrt(pow(((double) M_PI), 3.0)) / -180.0))) * (2.0 * (t_0 * sin((angle * (((double) M_PI) / -180.0)))));
} else if ((angle / 180.0) <= 5e+255) {
tmp = (2.0 * (sin(((angle * ((double) M_PI)) / -180.0)) * t_0)) * cbrt(pow(cos(t_1), 3.0));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin((t_1 * 2.0)) / 2.0);
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double t_0 = (a_m - b_m) * (a_m + b_m);
double t_1 = angle * (Math.PI * -0.005555555555555556);
double tmp;
if ((angle / 180.0) <= 1e-54) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else if ((angle / 180.0) <= 2e+64) {
tmp = Math.cos((angle * (Math.cbrt(Math.pow(Math.PI, 3.0)) / -180.0))) * (2.0 * (t_0 * Math.sin((angle * (Math.PI / -180.0)))));
} else if ((angle / 180.0) <= 5e+255) {
tmp = (2.0 * (Math.sin(((angle * Math.PI) / -180.0)) * t_0)) * Math.cbrt(Math.pow(Math.cos(t_1), 3.0));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (Math.sin((t_1 * 2.0)) / 2.0);
}
return tmp;
}
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) t_0 = Float64(Float64(a_m - b_m) * Float64(a_m + b_m)) t_1 = Float64(angle * Float64(pi * -0.005555555555555556)) tmp = 0.0 if (Float64(angle / 180.0) <= 1e-54) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); elseif (Float64(angle / 180.0) <= 2e+64) tmp = Float64(cos(Float64(angle * Float64(cbrt((pi ^ 3.0)) / -180.0))) * Float64(2.0 * Float64(t_0 * sin(Float64(angle * Float64(pi / -180.0)))))); elseif (Float64(angle / 180.0) <= 5e+255) tmp = Float64(Float64(2.0 * Float64(sin(Float64(Float64(angle * pi) / -180.0)) * t_0)) * cbrt((cos(t_1) ^ 3.0))); else tmp = Float64(Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))) * Float64(sin(Float64(t_1 * 2.0)) / 2.0)); end return tmp end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e-54], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+64], N[(N[Cos[N[(angle * N[(N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision] / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(t$95$0 * N[Sin[N[(angle * N[(Pi / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+255], N[(N[(2.0 * N[(N[Sin[N[(N[(angle * Pi), $MachinePrecision] / -180.0), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[N[Cos[t$95$1], $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(t$95$1 * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\\
t_1 := angle \cdot \left(\pi \cdot -0.005555555555555556\right)\\
\mathbf{if}\;\frac{angle}{180} \leq 10^{-54}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 2 \cdot 10^{+64}:\\
\;\;\;\;\cos \left(angle \cdot \frac{\sqrt[3]{{\pi}^{3}}}{-180}\right) \cdot \left(2 \cdot \left(t\_0 \cdot \sin \left(angle \cdot \frac{\pi}{-180}\right)\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 5 \cdot 10^{+255}:\\
\;\;\;\;\left(2 \cdot \left(\sin \left(\frac{angle \cdot \pi}{-180}\right) \cdot t\_0\right)\right) \cdot \sqrt[3]{{\cos t\_1}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right) \cdot \frac{\sin \left(t\_1 \cdot 2\right)}{2}\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1e-54Initial program 55.8%
Taylor expanded in angle around 0 49.7%
unpow249.7%
unpow249.7%
difference-of-squares51.9%
Applied egg-rr51.9%
Taylor expanded in b around 0 56.9%
+-commutative56.9%
mul-1-neg56.9%
unsub-neg56.9%
distribute-lft-out56.9%
+-commutative56.9%
*-commutative56.9%
distribute-rgt1-in56.9%
metadata-eval56.9%
mul0-lft56.9%
distribute-rgt-out56.9%
Simplified56.9%
if 1e-54 < (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000004e64Initial program 56.7%
Simplified60.7%
unpow263.4%
unpow263.4%
difference-of-squares63.4%
Applied egg-rr60.7%
add-cbrt-cube75.5%
pow375.5%
Applied egg-rr75.5%
if 2.00000000000000004e64 < (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000002e255Initial program 34.7%
Simplified31.2%
associate-*r/36.9%
Applied egg-rr36.9%
log1p-expm1-u36.9%
div-inv36.9%
metadata-eval36.9%
Applied egg-rr36.9%
unpow236.9%
unpow236.9%
difference-of-squares40.3%
Applied egg-rr40.3%
add-cbrt-cube40.3%
pow340.3%
log1p-expm1-u40.3%
Applied egg-rr40.3%
if 5.0000000000000002e255 < (/.f64 angle #s(literal 180 binary64)) Initial program 14.9%
associate-*l*14.9%
sin-cos-mult14.9%
associate-*r/14.9%
Applied egg-rr36.4%
associate-/l*36.4%
sin-036.4%
Simplified36.4%
unpow220.2%
unpow220.2%
difference-of-squares20.2%
Applied egg-rr45.5%
Final simplification56.5%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(if (<= (/ angle 180.0) 1e-55)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(if (<= (/ angle 180.0) 5e+255)
(*
(log1p (+ (exp (cos (* -0.005555555555555556 (* angle PI)))) -1.0))
(* 2.0 (* (sin (/ (* angle PI) -180.0)) (* (- a_m b_m) (+ a_m b_m)))))
(*
(* 2.0 (* (- b_m a_m) (+ a_m b_m)))
(/ (sin (* (* angle (* PI -0.005555555555555556)) 2.0)) 2.0)))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 1e-55) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else if ((angle / 180.0) <= 5e+255) {
tmp = log1p((exp(cos((-0.005555555555555556 * (angle * ((double) M_PI))))) + -1.0)) * (2.0 * (sin(((angle * ((double) M_PI)) / -180.0)) * ((a_m - b_m) * (a_m + b_m))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin(((angle * (((double) M_PI) * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 1e-55) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else if ((angle / 180.0) <= 5e+255) {
tmp = Math.log1p((Math.exp(Math.cos((-0.005555555555555556 * (angle * Math.PI)))) + -1.0)) * (2.0 * (Math.sin(((angle * Math.PI) / -180.0)) * ((a_m - b_m) * (a_m + b_m))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (Math.sin(((angle * (Math.PI * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if (angle / 180.0) <= 1e-55: tmp = 0.011111111111111112 * ((b_m * (angle * (math.pi * b_m))) - (math.pow(a_m, 2.0) * (angle * math.pi))) elif (angle / 180.0) <= 5e+255: tmp = math.log1p((math.exp(math.cos((-0.005555555555555556 * (angle * math.pi)))) + -1.0)) * (2.0 * (math.sin(((angle * math.pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m)))) else: tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (math.sin(((angle * (math.pi * -0.005555555555555556)) * 2.0)) / 2.0) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 1e-55) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); elseif (Float64(angle / 180.0) <= 5e+255) tmp = Float64(log1p(Float64(exp(cos(Float64(-0.005555555555555556 * Float64(angle * pi)))) + -1.0)) * Float64(2.0 * Float64(sin(Float64(Float64(angle * pi) / -180.0)) * Float64(Float64(a_m - b_m) * Float64(a_m + b_m))))); else tmp = Float64(Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))) * Float64(sin(Float64(Float64(angle * Float64(pi * -0.005555555555555556)) * 2.0)) / 2.0)); end return tmp end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e-55], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+255], N[(N[Log[1 + N[(N[Exp[N[Cos[N[(-0.005555555555555556 * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[Sin[N[(N[(angle * Pi), $MachinePrecision] / -180.0), $MachinePrecision]], $MachinePrecision] * N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 10^{-55}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 5 \cdot 10^{+255}:\\
\;\;\;\;\mathsf{log1p}\left(e^{\cos \left(-0.005555555555555556 \cdot \left(angle \cdot \pi\right)\right)} + -1\right) \cdot \left(2 \cdot \left(\sin \left(\frac{angle \cdot \pi}{-180}\right) \cdot \left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right) \cdot \frac{\sin \left(\left(angle \cdot \left(\pi \cdot -0.005555555555555556\right)\right) \cdot 2\right)}{2}\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999995e-56Initial program 55.5%
Taylor expanded in angle around 0 49.4%
unpow249.4%
unpow249.4%
difference-of-squares51.6%
Applied egg-rr51.6%
Taylor expanded in b around 0 56.7%
+-commutative56.7%
mul-1-neg56.7%
unsub-neg56.7%
distribute-lft-out56.7%
+-commutative56.7%
*-commutative56.7%
distribute-rgt1-in56.7%
metadata-eval56.7%
mul0-lft56.7%
distribute-rgt-out56.7%
Simplified56.7%
if 9.99999999999999995e-56 < (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000002e255Initial program 46.3%
Simplified46.4%
associate-*r/50.5%
Applied egg-rr50.5%
log1p-expm1-u50.5%
div-inv50.5%
metadata-eval50.5%
Applied egg-rr50.5%
unpow250.5%
unpow250.5%
difference-of-squares52.3%
Applied egg-rr52.3%
Taylor expanded in angle around inf 55.2%
if 5.0000000000000002e255 < (/.f64 angle #s(literal 180 binary64)) Initial program 14.9%
associate-*l*14.9%
sin-cos-mult14.9%
associate-*r/14.9%
Applied egg-rr36.4%
associate-/l*36.4%
sin-036.4%
Simplified36.4%
unpow220.2%
unpow220.2%
difference-of-squares20.2%
Applied egg-rr45.5%
Final simplification55.9%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(let* ((t_0 (* angle (* PI -0.005555555555555556))))
(if (<= (/ angle 180.0) 1e-55)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(if (<= (/ angle 180.0) 5e+255)
(*
(* 2.0 (* (sin (/ (* angle PI) -180.0)) (* (- a_m b_m) (+ a_m b_m))))
(log (exp (cos t_0))))
(* (* 2.0 (* (- b_m a_m) (+ a_m b_m))) (/ (sin (* t_0 2.0)) 2.0))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double t_0 = angle * (((double) M_PI) * -0.005555555555555556);
double tmp;
if ((angle / 180.0) <= 1e-55) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else if ((angle / 180.0) <= 5e+255) {
tmp = (2.0 * (sin(((angle * ((double) M_PI)) / -180.0)) * ((a_m - b_m) * (a_m + b_m)))) * log(exp(cos(t_0)));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin((t_0 * 2.0)) / 2.0);
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double t_0 = angle * (Math.PI * -0.005555555555555556);
double tmp;
if ((angle / 180.0) <= 1e-55) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else if ((angle / 180.0) <= 5e+255) {
tmp = (2.0 * (Math.sin(((angle * Math.PI) / -180.0)) * ((a_m - b_m) * (a_m + b_m)))) * Math.log(Math.exp(Math.cos(t_0)));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (Math.sin((t_0 * 2.0)) / 2.0);
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): t_0 = angle * (math.pi * -0.005555555555555556) tmp = 0 if (angle / 180.0) <= 1e-55: tmp = 0.011111111111111112 * ((b_m * (angle * (math.pi * b_m))) - (math.pow(a_m, 2.0) * (angle * math.pi))) elif (angle / 180.0) <= 5e+255: tmp = (2.0 * (math.sin(((angle * math.pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m)))) * math.log(math.exp(math.cos(t_0))) else: tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (math.sin((t_0 * 2.0)) / 2.0) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) t_0 = Float64(angle * Float64(pi * -0.005555555555555556)) tmp = 0.0 if (Float64(angle / 180.0) <= 1e-55) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); elseif (Float64(angle / 180.0) <= 5e+255) tmp = Float64(Float64(2.0 * Float64(sin(Float64(Float64(angle * pi) / -180.0)) * Float64(Float64(a_m - b_m) * Float64(a_m + b_m)))) * log(exp(cos(t_0)))); else tmp = Float64(Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))) * Float64(sin(Float64(t_0 * 2.0)) / 2.0)); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) t_0 = angle * (pi * -0.005555555555555556); tmp = 0.0; if ((angle / 180.0) <= 1e-55) tmp = 0.011111111111111112 * ((b_m * (angle * (pi * b_m))) - ((a_m ^ 2.0) * (angle * pi))); elseif ((angle / 180.0) <= 5e+255) tmp = (2.0 * (sin(((angle * pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m)))) * log(exp(cos(t_0))); else tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin((t_0 * 2.0)) / 2.0); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
b_m = N[Abs[b], $MachinePrecision]
code[a$95$m_, b$95$m_, angle_] := Block[{t$95$0 = N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e-55], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+255], N[(N[(2.0 * N[(N[Sin[N[(N[(angle * Pi), $MachinePrecision] / -180.0), $MachinePrecision]], $MachinePrecision] * N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Log[N[Exp[N[Cos[t$95$0], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := angle \cdot \left(\pi \cdot -0.005555555555555556\right)\\
\mathbf{if}\;\frac{angle}{180} \leq 10^{-55}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 5 \cdot 10^{+255}:\\
\;\;\;\;\left(2 \cdot \left(\sin \left(\frac{angle \cdot \pi}{-180}\right) \cdot \left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\right) \cdot \log \left(e^{\cos t\_0}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right) \cdot \frac{\sin \left(t\_0 \cdot 2\right)}{2}\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999995e-56Initial program 55.5%
Taylor expanded in angle around 0 49.4%
unpow249.4%
unpow249.4%
difference-of-squares51.6%
Applied egg-rr51.6%
Taylor expanded in b around 0 56.7%
+-commutative56.7%
mul-1-neg56.7%
unsub-neg56.7%
distribute-lft-out56.7%
+-commutative56.7%
*-commutative56.7%
distribute-rgt1-in56.7%
metadata-eval56.7%
mul0-lft56.7%
distribute-rgt-out56.7%
Simplified56.7%
if 9.99999999999999995e-56 < (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000002e255Initial program 46.3%
Simplified46.4%
associate-*r/50.5%
Applied egg-rr50.5%
log1p-expm1-u50.5%
div-inv50.5%
metadata-eval50.5%
Applied egg-rr50.5%
unpow250.5%
unpow250.5%
difference-of-squares52.3%
Applied egg-rr52.3%
add-log-exp52.3%
log1p-expm1-u52.3%
Applied egg-rr52.3%
if 5.0000000000000002e255 < (/.f64 angle #s(literal 180 binary64)) Initial program 14.9%
associate-*l*14.9%
sin-cos-mult14.9%
associate-*r/14.9%
Applied egg-rr36.4%
associate-/l*36.4%
sin-036.4%
Simplified36.4%
unpow220.2%
unpow220.2%
difference-of-squares20.2%
Applied egg-rr45.5%
Final simplification55.3%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(if (<= (/ angle 180.0) 1e-54)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(if (<= (/ angle 180.0) 1e+212)
(*
(cos (* angle (/ PI -180.0)))
(* 2.0 (* (* (- a_m b_m) (+ a_m b_m)) (sin (/ angle (/ -180.0 PI))))))
(*
(* 2.0 (* (- b_m a_m) (+ a_m b_m)))
(/ (sin (* (* angle (* PI -0.005555555555555556)) 2.0)) 2.0)))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 1e-54) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else if ((angle / 180.0) <= 1e+212) {
tmp = cos((angle * (((double) M_PI) / -180.0))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle / (-180.0 / ((double) M_PI))))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin(((angle * (((double) M_PI) * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 1e-54) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else if ((angle / 180.0) <= 1e+212) {
tmp = Math.cos((angle * (Math.PI / -180.0))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * Math.sin((angle / (-180.0 / Math.PI)))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (Math.sin(((angle * (Math.PI * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if (angle / 180.0) <= 1e-54: tmp = 0.011111111111111112 * ((b_m * (angle * (math.pi * b_m))) - (math.pow(a_m, 2.0) * (angle * math.pi))) elif (angle / 180.0) <= 1e+212: tmp = math.cos((angle * (math.pi / -180.0))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * math.sin((angle / (-180.0 / math.pi))))) else: tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (math.sin(((angle * (math.pi * -0.005555555555555556)) * 2.0)) / 2.0) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 1e-54) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); elseif (Float64(angle / 180.0) <= 1e+212) tmp = Float64(cos(Float64(angle * Float64(pi / -180.0))) * Float64(2.0 * Float64(Float64(Float64(a_m - b_m) * Float64(a_m + b_m)) * sin(Float64(angle / Float64(-180.0 / pi)))))); else tmp = Float64(Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))) * Float64(sin(Float64(Float64(angle * Float64(pi * -0.005555555555555556)) * 2.0)) / 2.0)); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if ((angle / 180.0) <= 1e-54) tmp = 0.011111111111111112 * ((b_m * (angle * (pi * b_m))) - ((a_m ^ 2.0) * (angle * pi))); elseif ((angle / 180.0) <= 1e+212) tmp = cos((angle * (pi / -180.0))) * (2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle / (-180.0 / pi))))); else tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin(((angle * (pi * -0.005555555555555556)) * 2.0)) / 2.0); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e-54], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+212], N[(N[Cos[N[(angle * N[(Pi / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(angle / N[(-180.0 / Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 10^{-54}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+212}:\\
\;\;\;\;\cos \left(angle \cdot \frac{\pi}{-180}\right) \cdot \left(2 \cdot \left(\left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right) \cdot \sin \left(\frac{angle}{\frac{-180}{\pi}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right) \cdot \frac{\sin \left(\left(angle \cdot \left(\pi \cdot -0.005555555555555556\right)\right) \cdot 2\right)}{2}\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1e-54Initial program 55.8%
Taylor expanded in angle around 0 49.7%
unpow249.7%
unpow249.7%
difference-of-squares51.9%
Applied egg-rr51.9%
Taylor expanded in b around 0 56.9%
+-commutative56.9%
mul-1-neg56.9%
unsub-neg56.9%
distribute-lft-out56.9%
+-commutative56.9%
*-commutative56.9%
distribute-rgt1-in56.9%
metadata-eval56.9%
mul0-lft56.9%
distribute-rgt-out56.9%
Simplified56.9%
if 1e-54 < (/.f64 angle #s(literal 180 binary64)) < 9.9999999999999991e211Initial program 47.9%
Simplified48.0%
unpow250.6%
unpow250.6%
difference-of-squares52.4%
Applied egg-rr49.9%
clear-num49.9%
un-div-inv51.7%
Applied egg-rr51.7%
if 9.9999999999999991e211 < (/.f64 angle #s(literal 180 binary64)) Initial program 11.8%
associate-*l*11.8%
sin-cos-mult11.8%
associate-*r/11.8%
Applied egg-rr44.3%
associate-/l*44.3%
sin-044.3%
Simplified44.3%
unpow216.1%
unpow216.1%
difference-of-squares16.1%
Applied egg-rr51.5%
Final simplification55.6%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(if (<= angle 6e-52)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(if (<= angle 7.5e+216)
(*
(cos (* angle (/ PI -180.0)))
(*
2.0
(*
(sin (* PI (* angle -0.005555555555555556)))
(* (- a_m b_m) (+ a_m b_m)))))
(*
(* 2.0 (* (- b_m a_m) (+ a_m b_m)))
(/ (sin (* (* angle (* PI -0.005555555555555556)) 2.0)) 2.0)))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (angle <= 6e-52) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else if (angle <= 7.5e+216) {
tmp = cos((angle * (((double) M_PI) / -180.0))) * (2.0 * (sin((((double) M_PI) * (angle * -0.005555555555555556))) * ((a_m - b_m) * (a_m + b_m))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin(((angle * (((double) M_PI) * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (angle <= 6e-52) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else if (angle <= 7.5e+216) {
tmp = Math.cos((angle * (Math.PI / -180.0))) * (2.0 * (Math.sin((Math.PI * (angle * -0.005555555555555556))) * ((a_m - b_m) * (a_m + b_m))));
} else {
tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (Math.sin(((angle * (Math.PI * -0.005555555555555556)) * 2.0)) / 2.0);
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if angle <= 6e-52: tmp = 0.011111111111111112 * ((b_m * (angle * (math.pi * b_m))) - (math.pow(a_m, 2.0) * (angle * math.pi))) elif angle <= 7.5e+216: tmp = math.cos((angle * (math.pi / -180.0))) * (2.0 * (math.sin((math.pi * (angle * -0.005555555555555556))) * ((a_m - b_m) * (a_m + b_m)))) else: tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (math.sin(((angle * (math.pi * -0.005555555555555556)) * 2.0)) / 2.0) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (angle <= 6e-52) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); elseif (angle <= 7.5e+216) tmp = Float64(cos(Float64(angle * Float64(pi / -180.0))) * Float64(2.0 * Float64(sin(Float64(pi * Float64(angle * -0.005555555555555556))) * Float64(Float64(a_m - b_m) * Float64(a_m + b_m))))); else tmp = Float64(Float64(2.0 * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))) * Float64(sin(Float64(Float64(angle * Float64(pi * -0.005555555555555556)) * 2.0)) / 2.0)); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if (angle <= 6e-52) tmp = 0.011111111111111112 * ((b_m * (angle * (pi * b_m))) - ((a_m ^ 2.0) * (angle * pi))); elseif (angle <= 7.5e+216) tmp = cos((angle * (pi / -180.0))) * (2.0 * (sin((pi * (angle * -0.005555555555555556))) * ((a_m - b_m) * (a_m + b_m)))); else tmp = (2.0 * ((b_m - a_m) * (a_m + b_m))) * (sin(((angle * (pi * -0.005555555555555556)) * 2.0)) / 2.0); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[angle, 6e-52], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle, 7.5e+216], N[(N[Cos[N[(angle * N[(Pi / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[Sin[N[(Pi * N[(angle * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[N[(N[(angle * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 6 \cdot 10^{-52}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{elif}\;angle \leq 7.5 \cdot 10^{+216}:\\
\;\;\;\;\cos \left(angle \cdot \frac{\pi}{-180}\right) \cdot \left(2 \cdot \left(\sin \left(\pi \cdot \left(angle \cdot -0.005555555555555556\right)\right) \cdot \left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right) \cdot \frac{\sin \left(\left(angle \cdot \left(\pi \cdot -0.005555555555555556\right)\right) \cdot 2\right)}{2}\\
\end{array}
\end{array}
if angle < 6e-52Initial program 55.8%
Taylor expanded in angle around 0 49.7%
unpow249.7%
unpow249.7%
difference-of-squares51.9%
Applied egg-rr51.9%
Taylor expanded in b around 0 56.9%
+-commutative56.9%
mul-1-neg56.9%
unsub-neg56.9%
distribute-lft-out56.9%
+-commutative56.9%
*-commutative56.9%
distribute-rgt1-in56.9%
metadata-eval56.9%
mul0-lft56.9%
distribute-rgt-out56.9%
Simplified56.9%
if 6e-52 < angle < 7.4999999999999994e216Initial program 47.9%
Simplified48.0%
unpow250.6%
unpow250.6%
difference-of-squares52.4%
Applied egg-rr49.9%
Taylor expanded in angle around 0 51.7%
associate-*r*54.3%
Simplified54.3%
if 7.4999999999999994e216 < angle Initial program 11.8%
associate-*l*11.8%
sin-cos-mult11.8%
associate-*r/11.8%
Applied egg-rr44.3%
associate-/l*44.3%
sin-044.3%
Simplified44.3%
unpow216.1%
unpow216.1%
difference-of-squares16.1%
Applied egg-rr51.5%
Final simplification56.1%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (if (<= (pow a_m 2.0) 2e+306) (* 2.0 (* (* (- a_m b_m) (+ a_m b_m)) (sin (* angle (/ PI -180.0))))) (* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (pow(a_m, 2.0) <= 2e+306) {
tmp = 2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle * (((double) M_PI) / -180.0))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (Math.pow(a_m, 2.0) <= 2e+306) {
tmp = 2.0 * (((a_m - b_m) * (a_m + b_m)) * Math.sin((angle * (Math.PI / -180.0))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if math.pow(a_m, 2.0) <= 2e+306: tmp = 2.0 * (((a_m - b_m) * (a_m + b_m)) * math.sin((angle * (math.pi / -180.0)))) else: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if ((a_m ^ 2.0) <= 2e+306) tmp = Float64(2.0 * Float64(Float64(Float64(a_m - b_m) * Float64(a_m + b_m)) * sin(Float64(angle * Float64(pi / -180.0))))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if ((a_m ^ 2.0) <= 2e+306) tmp = 2.0 * (((a_m - b_m) * (a_m + b_m)) * sin((angle * (pi / -180.0)))); else tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[N[Power[a$95$m, 2.0], $MachinePrecision], 2e+306], N[(2.0 * N[(N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(angle * N[(Pi / -180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;{a\_m}^{2} \leq 2 \cdot 10^{+306}:\\
\;\;\;\;2 \cdot \left(\left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right) \cdot \sin \left(angle \cdot \frac{\pi}{-180}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\end{array}
\end{array}
if (pow.f64 a #s(literal 2 binary64)) < 2.00000000000000003e306Initial program 57.5%
Simplified57.6%
unpow258.2%
unpow258.2%
difference-of-squares58.2%
Applied egg-rr57.6%
Taylor expanded in angle around 0 53.2%
if 2.00000000000000003e306 < (pow.f64 a #s(literal 2 binary64)) Initial program 33.0%
Taylor expanded in angle around 0 33.0%
unpow233.0%
unpow233.0%
difference-of-squares39.8%
Applied egg-rr39.8%
Taylor expanded in b around 0 44.8%
Taylor expanded in angle around 0 69.9%
associate-*r*69.9%
Simplified69.9%
Final simplification57.1%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(if (<= a_m 1.1e-230)
(* 2.0 (* (sin (/ (* angle PI) -180.0)) (* (- a_m b_m) (+ a_m b_m))))
(if (<= a_m 9.6e+117)
(+
(* (* (pow a_m 2.0) (* angle PI)) -0.011111111111111112)
(*
b_m
(+
(* 0.011111111111111112 (* angle (* PI b_m)))
(* 0.011111111111111112 (* angle (* PI (- a_m a_m)))))))
(* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m)))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 1.1e-230) {
tmp = 2.0 * (sin(((angle * ((double) M_PI)) / -180.0)) * ((a_m - b_m) * (a_m + b_m)));
} else if (a_m <= 9.6e+117) {
tmp = ((pow(a_m, 2.0) * (angle * ((double) M_PI))) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (((double) M_PI) * b_m))) + (0.011111111111111112 * (angle * (((double) M_PI) * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 1.1e-230) {
tmp = 2.0 * (Math.sin(((angle * Math.PI) / -180.0)) * ((a_m - b_m) * (a_m + b_m)));
} else if (a_m <= 9.6e+117) {
tmp = ((Math.pow(a_m, 2.0) * (angle * Math.PI)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (Math.PI * b_m))) + (0.011111111111111112 * (angle * (Math.PI * (a_m - a_m))))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if a_m <= 1.1e-230: tmp = 2.0 * (math.sin(((angle * math.pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m))) elif a_m <= 9.6e+117: tmp = ((math.pow(a_m, 2.0) * (angle * math.pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (math.pi * b_m))) + (0.011111111111111112 * (angle * (math.pi * (a_m - a_m)))))) else: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (a_m <= 1.1e-230) tmp = Float64(2.0 * Float64(sin(Float64(Float64(angle * pi) / -180.0)) * Float64(Float64(a_m - b_m) * Float64(a_m + b_m)))); elseif (a_m <= 9.6e+117) tmp = Float64(Float64(Float64((a_m ^ 2.0) * Float64(angle * pi)) * -0.011111111111111112) + Float64(b_m * Float64(Float64(0.011111111111111112 * Float64(angle * Float64(pi * b_m))) + Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(a_m - a_m))))))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if (a_m <= 1.1e-230) tmp = 2.0 * (sin(((angle * pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m))); elseif (a_m <= 9.6e+117) tmp = (((a_m ^ 2.0) * (angle * pi)) * -0.011111111111111112) + (b_m * ((0.011111111111111112 * (angle * (pi * b_m))) + (0.011111111111111112 * (angle * (pi * (a_m - a_m)))))); else tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[a$95$m, 1.1e-230], N[(2.0 * N[(N[Sin[N[(N[(angle * Pi), $MachinePrecision] / -180.0), $MachinePrecision]], $MachinePrecision] * N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 9.6e+117], N[(N[(N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision] * -0.011111111111111112), $MachinePrecision] + N[(b$95$m * N[(N[(0.011111111111111112 * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.011111111111111112 * N[(angle * N[(Pi * N[(a$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 1.1 \cdot 10^{-230}:\\
\;\;\;\;2 \cdot \left(\sin \left(\frac{angle \cdot \pi}{-180}\right) \cdot \left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\\
\mathbf{elif}\;a\_m \leq 9.6 \cdot 10^{+117}:\\
\;\;\;\;\left({a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right) \cdot -0.011111111111111112 + b\_m \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) + 0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(a\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\end{array}
\end{array}
if a < 1.0999999999999999e-230Initial program 48.3%
Simplified48.5%
associate-*r/50.4%
Applied egg-rr50.4%
log1p-expm1-u50.4%
div-inv50.4%
metadata-eval50.4%
Applied egg-rr50.4%
unpow250.4%
unpow250.4%
difference-of-squares52.8%
Applied egg-rr52.8%
Taylor expanded in angle around 0 50.6%
if 1.0999999999999999e-230 < a < 9.5999999999999996e117Initial program 63.3%
Taylor expanded in angle around 0 52.2%
unpow252.2%
unpow252.2%
difference-of-squares52.2%
Applied egg-rr52.2%
Taylor expanded in b around 0 60.9%
if 9.5999999999999996e117 < a Initial program 39.1%
Taylor expanded in angle around 0 38.5%
unpow238.5%
unpow238.5%
difference-of-squares43.1%
Applied egg-rr43.1%
Taylor expanded in b around 0 45.4%
Taylor expanded in angle around 0 62.9%
associate-*r*63.0%
Simplified63.0%
Final simplification56.1%
a_m = (fabs.f64 a)
b_m = (fabs.f64 b)
(FPCore (a_m b_m angle)
:precision binary64
(if (<= a_m 3.5e-231)
(* 2.0 (* (sin (/ (* angle PI) -180.0)) (* (- a_m b_m) (+ a_m b_m))))
(if (<= a_m 9.6e+117)
(*
0.011111111111111112
(- (* b_m (* angle (* PI b_m))) (* (pow a_m 2.0) (* angle PI))))
(* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m)))))))a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 3.5e-231) {
tmp = 2.0 * (sin(((angle * ((double) M_PI)) / -180.0)) * ((a_m - b_m) * (a_m + b_m)));
} else if (a_m <= 9.6e+117) {
tmp = 0.011111111111111112 * ((b_m * (angle * (((double) M_PI) * b_m))) - (pow(a_m, 2.0) * (angle * ((double) M_PI))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 3.5e-231) {
tmp = 2.0 * (Math.sin(((angle * Math.PI) / -180.0)) * ((a_m - b_m) * (a_m + b_m)));
} else if (a_m <= 9.6e+117) {
tmp = 0.011111111111111112 * ((b_m * (angle * (Math.PI * b_m))) - (Math.pow(a_m, 2.0) * (angle * Math.PI)));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if a_m <= 3.5e-231: tmp = 2.0 * (math.sin(((angle * math.pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m))) elif a_m <= 9.6e+117: tmp = 0.011111111111111112 * ((b_m * (angle * (math.pi * b_m))) - (math.pow(a_m, 2.0) * (angle * math.pi))) else: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (a_m <= 3.5e-231) tmp = Float64(2.0 * Float64(sin(Float64(Float64(angle * pi) / -180.0)) * Float64(Float64(a_m - b_m) * Float64(a_m + b_m)))); elseif (a_m <= 9.6e+117) tmp = Float64(0.011111111111111112 * Float64(Float64(b_m * Float64(angle * Float64(pi * b_m))) - Float64((a_m ^ 2.0) * Float64(angle * pi)))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if (a_m <= 3.5e-231) tmp = 2.0 * (sin(((angle * pi) / -180.0)) * ((a_m - b_m) * (a_m + b_m))); elseif (a_m <= 9.6e+117) tmp = 0.011111111111111112 * ((b_m * (angle * (pi * b_m))) - ((a_m ^ 2.0) * (angle * pi))); else tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[a$95$m, 3.5e-231], N[(2.0 * N[(N[Sin[N[(N[(angle * Pi), $MachinePrecision] / -180.0), $MachinePrecision]], $MachinePrecision] * N[(N[(a$95$m - b$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 9.6e+117], N[(0.011111111111111112 * N[(N[(b$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[a$95$m, 2.0], $MachinePrecision] * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 3.5 \cdot 10^{-231}:\\
\;\;\;\;2 \cdot \left(\sin \left(\frac{angle \cdot \pi}{-180}\right) \cdot \left(\left(a\_m - b\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\\
\mathbf{elif}\;a\_m \leq 9.6 \cdot 10^{+117}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right) - {a\_m}^{2} \cdot \left(angle \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\end{array}
\end{array}
if a < 3.5000000000000001e-231Initial program 48.3%
Simplified48.5%
associate-*r/50.4%
Applied egg-rr50.4%
log1p-expm1-u50.4%
div-inv50.4%
metadata-eval50.4%
Applied egg-rr50.4%
unpow250.4%
unpow250.4%
difference-of-squares52.8%
Applied egg-rr52.8%
Taylor expanded in angle around 0 50.6%
if 3.5000000000000001e-231 < a < 9.5999999999999996e117Initial program 63.3%
Taylor expanded in angle around 0 52.2%
unpow252.2%
unpow252.2%
difference-of-squares52.2%
Applied egg-rr52.2%
Taylor expanded in b around 0 60.8%
+-commutative60.8%
mul-1-neg60.8%
unsub-neg60.8%
distribute-lft-out60.8%
+-commutative60.8%
*-commutative60.8%
distribute-rgt1-in60.8%
metadata-eval60.8%
mul0-lft60.8%
distribute-rgt-out60.8%
Simplified60.8%
if 9.5999999999999996e117 < a Initial program 39.1%
Taylor expanded in angle around 0 38.5%
unpow238.5%
unpow238.5%
difference-of-squares43.1%
Applied egg-rr43.1%
Taylor expanded in b around 0 45.4%
Taylor expanded in angle around 0 62.9%
associate-*r*63.0%
Simplified63.0%
Final simplification56.1%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (if (<= (pow a_m 2.0) 1e+157) (* 0.011111111111111112 (* angle (* PI (* (- b_m a_m) (+ a_m b_m))))) (* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (pow(a_m, 2.0) <= 1e+157) {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * ((b_m - a_m) * (a_m + b_m))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (Math.pow(a_m, 2.0) <= 1e+157) {
tmp = 0.011111111111111112 * (angle * (Math.PI * ((b_m - a_m) * (a_m + b_m))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if math.pow(a_m, 2.0) <= 1e+157: tmp = 0.011111111111111112 * (angle * (math.pi * ((b_m - a_m) * (a_m + b_m)))) else: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if ((a_m ^ 2.0) <= 1e+157) tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(Float64(b_m - a_m) * Float64(a_m + b_m))))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if ((a_m ^ 2.0) <= 1e+157) tmp = 0.011111111111111112 * (angle * (pi * ((b_m - a_m) * (a_m + b_m)))); else tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[N[Power[a$95$m, 2.0], $MachinePrecision], 1e+157], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(N[(b$95$m - a$95$m), $MachinePrecision] * N[(a$95$m + b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;{a\_m}^{2} \leq 10^{+157}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(\left(b\_m - a\_m\right) \cdot \left(a\_m + b\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\end{array}
\end{array}
if (pow.f64 a #s(literal 2 binary64)) < 9.99999999999999983e156Initial program 59.5%
Taylor expanded in angle around 0 50.1%
unpow250.1%
unpow250.1%
difference-of-squares50.1%
Applied egg-rr50.1%
if 9.99999999999999983e156 < (pow.f64 a #s(literal 2 binary64)) Initial program 37.1%
Taylor expanded in angle around 0 36.3%
unpow236.3%
unpow236.3%
difference-of-squares40.8%
Applied egg-rr40.8%
Taylor expanded in b around 0 45.2%
Taylor expanded in angle around 0 62.1%
associate-*r*62.2%
Simplified62.2%
Final simplification54.3%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (if (<= a_m 8e+32) (* 0.011111111111111112 (* angle (* PI (* b_m (- b_m a_m))))) (* 0.011111111111111112 (* a_m (* (* angle PI) (- b_m a_m))))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 8e+32) {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * (b_m - a_m))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * ((double) M_PI)) * (b_m - a_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (a_m <= 8e+32) {
tmp = 0.011111111111111112 * (angle * (Math.PI * (b_m * (b_m - a_m))));
} else {
tmp = 0.011111111111111112 * (a_m * ((angle * Math.PI) * (b_m - a_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if a_m <= 8e+32: tmp = 0.011111111111111112 * (angle * (math.pi * (b_m * (b_m - a_m)))) else: tmp = 0.011111111111111112 * (a_m * ((angle * math.pi) * (b_m - a_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (a_m <= 8e+32) tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * Float64(b_m - a_m))))); else tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(Float64(angle * pi) * Float64(b_m - a_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if (a_m <= 8e+32) tmp = 0.011111111111111112 * (angle * (pi * (b_m * (b_m - a_m)))); else tmp = 0.011111111111111112 * (a_m * ((angle * pi) * (b_m - a_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[a$95$m, 8e+32], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(a$95$m * N[(N[(angle * Pi), $MachinePrecision] * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 8 \cdot 10^{+32}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot \left(b\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(\left(angle \cdot \pi\right) \cdot \left(b\_m - a\_m\right)\right)\right)\\
\end{array}
\end{array}
if a < 8.00000000000000043e32Initial program 53.2%
Taylor expanded in angle around 0 45.8%
unpow245.8%
unpow245.8%
difference-of-squares46.8%
Applied egg-rr46.8%
Taylor expanded in b around inf 39.6%
if 8.00000000000000043e32 < a Initial program 47.0%
Taylor expanded in angle around 0 43.8%
unpow243.8%
unpow243.8%
difference-of-squares47.1%
Applied egg-rr47.1%
Taylor expanded in b around 0 48.8%
Taylor expanded in angle around 0 61.3%
associate-*r*61.4%
Simplified61.4%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (if (<= angle 9.2e+232) (* 0.011111111111111112 (* a_m (* angle (* PI (- b_m a_m))))) (* 0.011111111111111112 (* angle (* a_m (* PI b_m))))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
double tmp;
if (angle <= 9.2e+232) {
tmp = 0.011111111111111112 * (a_m * (angle * (((double) M_PI) * (b_m - a_m))));
} else {
tmp = 0.011111111111111112 * (angle * (a_m * (((double) M_PI) * b_m)));
}
return tmp;
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
double tmp;
if (angle <= 9.2e+232) {
tmp = 0.011111111111111112 * (a_m * (angle * (Math.PI * (b_m - a_m))));
} else {
tmp = 0.011111111111111112 * (angle * (a_m * (Math.PI * b_m)));
}
return tmp;
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): tmp = 0 if angle <= 9.2e+232: tmp = 0.011111111111111112 * (a_m * (angle * (math.pi * (b_m - a_m)))) else: tmp = 0.011111111111111112 * (angle * (a_m * (math.pi * b_m))) return tmp
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) tmp = 0.0 if (angle <= 9.2e+232) tmp = Float64(0.011111111111111112 * Float64(a_m * Float64(angle * Float64(pi * Float64(b_m - a_m))))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(a_m * Float64(pi * b_m)))); end return tmp end
a_m = abs(a); b_m = abs(b); function tmp_2 = code(a_m, b_m, angle) tmp = 0.0; if (angle <= 9.2e+232) tmp = 0.011111111111111112 * (a_m * (angle * (pi * (b_m - a_m)))); else tmp = 0.011111111111111112 * (angle * (a_m * (pi * b_m))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := If[LessEqual[angle, 9.2e+232], N[(0.011111111111111112 * N[(a$95$m * N[(angle * N[(Pi * N[(b$95$m - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(a$95$m * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 9.2 \cdot 10^{+232}:\\
\;\;\;\;0.011111111111111112 \cdot \left(a\_m \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(a\_m \cdot \left(\pi \cdot b\_m\right)\right)\right)\\
\end{array}
\end{array}
if angle < 9.20000000000000024e232Initial program 53.6%
Taylor expanded in angle around 0 46.6%
unpow246.6%
unpow246.6%
difference-of-squares48.3%
Applied egg-rr48.3%
Taylor expanded in b around 0 31.4%
Taylor expanded in angle around 0 37.6%
if 9.20000000000000024e232 < angle Initial program 13.6%
Taylor expanded in angle around 0 18.5%
unpow218.5%
unpow218.5%
difference-of-squares18.5%
Applied egg-rr18.5%
Taylor expanded in b around 0 26.8%
Taylor expanded in a around 0 36.1%
Final simplification37.5%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (* 0.011111111111111112 (* angle (* a_m (* PI b_m)))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
return 0.011111111111111112 * (angle * (a_m * (((double) M_PI) * b_m)));
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
return 0.011111111111111112 * (angle * (a_m * (Math.PI * b_m)));
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): return 0.011111111111111112 * (angle * (a_m * (math.pi * b_m)))
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) return Float64(0.011111111111111112 * Float64(angle * Float64(a_m * Float64(pi * b_m)))) end
a_m = abs(a); b_m = abs(b); function tmp = code(a_m, b_m, angle) tmp = 0.011111111111111112 * (angle * (a_m * (pi * b_m))); end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := N[(0.011111111111111112 * N[(angle * N[(a$95$m * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
0.011111111111111112 \cdot \left(angle \cdot \left(a\_m \cdot \left(\pi \cdot b\_m\right)\right)\right)
\end{array}
Initial program 51.7%
Taylor expanded in angle around 0 45.3%
unpow245.3%
unpow245.3%
difference-of-squares46.9%
Applied egg-rr46.9%
Taylor expanded in b around 0 31.2%
Taylor expanded in a around 0 16.3%
Final simplification16.3%
a_m = (fabs.f64 a) b_m = (fabs.f64 b) (FPCore (a_m b_m angle) :precision binary64 (* 0.011111111111111112 (* a_m (* angle (* PI b_m)))))
a_m = fabs(a);
b_m = fabs(b);
double code(double a_m, double b_m, double angle) {
return 0.011111111111111112 * (a_m * (angle * (((double) M_PI) * b_m)));
}
a_m = Math.abs(a);
b_m = Math.abs(b);
public static double code(double a_m, double b_m, double angle) {
return 0.011111111111111112 * (a_m * (angle * (Math.PI * b_m)));
}
a_m = math.fabs(a) b_m = math.fabs(b) def code(a_m, b_m, angle): return 0.011111111111111112 * (a_m * (angle * (math.pi * b_m)))
a_m = abs(a) b_m = abs(b) function code(a_m, b_m, angle) return Float64(0.011111111111111112 * Float64(a_m * Float64(angle * Float64(pi * b_m)))) end
a_m = abs(a); b_m = abs(b); function tmp = code(a_m, b_m, angle) tmp = 0.011111111111111112 * (a_m * (angle * (pi * b_m))); end
a_m = N[Abs[a], $MachinePrecision] b_m = N[Abs[b], $MachinePrecision] code[a$95$m_, b$95$m_, angle_] := N[(0.011111111111111112 * N[(a$95$m * N[(angle * N[(Pi * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
b_m = \left|b\right|
\\
0.011111111111111112 \cdot \left(a\_m \cdot \left(angle \cdot \left(\pi \cdot b\_m\right)\right)\right)
\end{array}
Initial program 51.7%
Taylor expanded in angle around 0 45.3%
unpow245.3%
unpow245.3%
difference-of-squares46.9%
Applied egg-rr46.9%
Taylor expanded in b around 0 31.2%
Taylor expanded in a around 0 16.0%
Final simplification16.0%
herbie shell --seed 2024185
(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)))))