
(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 20 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}
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (cbrt (pow PI 1.5))) (t_1 (* t_0 t_0)))
(if (<= b_m 5.3e-70)
(*
(*
(- b_m a)
(* (+ b_m a) (* 2.0 (sin (/ (cbrt (* PI (* PI PI))) (/ 180.0 angle))))))
(cos (* t_1 (/ angle 180.0))))
(if (<= b_m 1.18e+232)
(*
(* (- b_m a) (* (+ b_m a) (* 2.0 (sin (/ PI (/ 180.0 angle))))))
(cos
(*
(pow (/ 180.0 (sqrt PI)) -1.0)
(pow (/ (/ 1.0 angle) (sqrt PI)) -1.0))))
(* (- b_m a) (* (+ b_m a) (* 2.0 (sin (/ t_1 (/ 180.0 angle))))))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = cbrt(pow(((double) M_PI), 1.5));
double t_1 = t_0 * t_0;
double tmp;
if (b_m <= 5.3e-70) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((cbrt((((double) M_PI) * (((double) M_PI) * ((double) M_PI)))) / (180.0 / angle)))))) * cos((t_1 * (angle / 180.0)));
} else if (b_m <= 1.18e+232) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((((double) M_PI) / (180.0 / angle)))))) * cos((pow((180.0 / sqrt(((double) M_PI))), -1.0) * pow(((1.0 / angle) / sqrt(((double) M_PI))), -1.0)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * sin((t_1 / (180.0 / angle)))));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.cbrt(Math.pow(Math.PI, 1.5));
double t_1 = t_0 * t_0;
double tmp;
if (b_m <= 5.3e-70) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.cbrt((Math.PI * (Math.PI * Math.PI))) / (180.0 / angle)))))) * Math.cos((t_1 * (angle / 180.0)));
} else if (b_m <= 1.18e+232) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.PI / (180.0 / angle)))))) * Math.cos((Math.pow((180.0 / Math.sqrt(Math.PI)), -1.0) * Math.pow(((1.0 / angle) / Math.sqrt(Math.PI)), -1.0)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * Math.sin((t_1 / (180.0 / angle)))));
}
return tmp;
}
b_m = abs(b) function code(a, b_m, angle) t_0 = cbrt((pi ^ 1.5)) t_1 = Float64(t_0 * t_0) tmp = 0.0 if (b_m <= 5.3e-70) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(cbrt(Float64(pi * Float64(pi * pi))) / Float64(180.0 / angle)))))) * cos(Float64(t_1 * Float64(angle / 180.0)))); elseif (b_m <= 1.18e+232) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle)))))) * cos(Float64((Float64(180.0 / sqrt(pi)) ^ -1.0) * (Float64(Float64(1.0 / angle) / sqrt(pi)) ^ -1.0)))); else tmp = Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(t_1 / Float64(180.0 / angle)))))); end return tmp end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[Power[N[Power[Pi, 1.5], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * t$95$0), $MachinePrecision]}, If[LessEqual[b$95$m, 5.3e-70], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(t$95$1 * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[b$95$m, 1.18e+232], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[Power[N[(180.0 / N[Sqrt[Pi], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision] * N[Power[N[(N[(1.0 / angle), $MachinePrecision] / N[Sqrt[Pi], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(t$95$1 / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \sqrt[3]{{\pi}^{1.5}}\\
t_1 := t\_0 \cdot t\_0\\
\mathbf{if}\;b\_m \leq 5.3 \cdot 10^{-70}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt[3]{\pi \cdot \left(\pi \cdot \pi\right)}}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(t\_1 \cdot \frac{angle}{180}\right)\\
\mathbf{elif}\;b\_m \leq 1.18 \cdot 10^{+232}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left({\left(\frac{180}{\sqrt{\pi}}\right)}^{-1} \cdot {\left(\frac{\frac{1}{angle}}{\sqrt{\pi}}\right)}^{-1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{t\_1}{\frac{180}{angle}}\right)\right)\right)\\
\end{array}
\end{array}
if b < 5.29999999999999983e-70Initial program 60.3%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6470.0%
Applied egg-rr70.0%
add-cbrt-cubeN/A
cbrt-lowering-cbrt.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6468.6%
Applied egg-rr68.6%
rem-cbrt-cubeN/A
sqr-powN/A
cbrt-prodN/A
*-lowering-*.f64N/A
cbrt-lowering-cbrt.f64N/A
pow-lowering-pow.f64N/A
PI-lowering-PI.f64N/A
metadata-evalN/A
cbrt-lowering-cbrt.f64N/A
pow-lowering-pow.f64N/A
PI-lowering-PI.f64N/A
metadata-eval72.3%
Applied egg-rr72.3%
if 5.29999999999999983e-70 < b < 1.18e232Initial program 47.7%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6458.6%
Applied egg-rr58.6%
clear-numN/A
div-invN/A
clear-numN/A
inv-powN/A
div-invN/A
add-sqr-sqrtN/A
times-fracN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f6464.9%
Applied egg-rr64.9%
if 1.18e232 < b Initial program 63.6%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6454.5%
Applied egg-rr54.5%
Taylor expanded in angle around 0
Simplified72.7%
rem-cbrt-cubeN/A
sqr-powN/A
cbrt-prodN/A
*-lowering-*.f64N/A
cbrt-lowering-cbrt.f64N/A
pow-lowering-pow.f64N/A
PI-lowering-PI.f64N/A
metadata-evalN/A
cbrt-lowering-cbrt.f64N/A
pow-lowering-pow.f64N/A
PI-lowering-PI.f64N/A
metadata-eval90.9%
Applied egg-rr90.9%
Final simplification71.3%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0
(/
(/ (/ 1.0 (- b_m a)) (+ b_m a))
(sin (* 0.011111111111111112 (* PI angle))))))
(if (<= (/ angle 180.0) 5e+66)
(*
(* (- b_m a) (* (+ b_m a) (* 2.0 (sin (/ PI (/ 180.0 angle))))))
(cos (* (/ angle 180.0) (pow (sqrt PI) 2.0))))
(if (<= (/ angle 180.0) 5e+199)
(pow (* t_0 t_0) -0.5)
(*
(*
(- b_m a)
(*
(+ b_m a)
(* 2.0 (sin (* (/ (sqrt PI) 180.0) (* angle (sqrt PI)))))))
(cos (* (* PI angle) 0.005555555555555556)))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / sin((0.011111111111111112 * (((double) M_PI) * angle)));
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((((double) M_PI) / (180.0 / angle)))))) * cos(((angle / 180.0) * pow(sqrt(((double) M_PI)), 2.0)));
} else if ((angle / 180.0) <= 5e+199) {
tmp = pow((t_0 * t_0), -0.5);
} else {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin(((sqrt(((double) M_PI)) / 180.0) * (angle * sqrt(((double) M_PI)))))))) * cos(((((double) M_PI) * angle) * 0.005555555555555556));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / Math.sin((0.011111111111111112 * (Math.PI * angle)));
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.PI / (180.0 / angle)))))) * Math.cos(((angle / 180.0) * Math.pow(Math.sqrt(Math.PI), 2.0)));
} else if ((angle / 180.0) <= 5e+199) {
tmp = Math.pow((t_0 * t_0), -0.5);
} else {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin(((Math.sqrt(Math.PI) / 180.0) * (angle * Math.sqrt(Math.PI))))))) * Math.cos(((Math.PI * angle) * 0.005555555555555556));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / math.sin((0.011111111111111112 * (math.pi * angle))) tmp = 0 if (angle / 180.0) <= 5e+66: tmp = ((b_m - a) * ((b_m + a) * (2.0 * math.sin((math.pi / (180.0 / angle)))))) * math.cos(((angle / 180.0) * math.pow(math.sqrt(math.pi), 2.0))) elif (angle / 180.0) <= 5e+199: tmp = math.pow((t_0 * t_0), -0.5) else: tmp = ((b_m - a) * ((b_m + a) * (2.0 * math.sin(((math.sqrt(math.pi) / 180.0) * (angle * math.sqrt(math.pi))))))) * math.cos(((math.pi * angle) * 0.005555555555555556)) return tmp
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(Float64(Float64(1.0 / Float64(b_m - a)) / Float64(b_m + a)) / sin(Float64(0.011111111111111112 * Float64(pi * angle)))) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle)))))) * cos(Float64(Float64(angle / 180.0) * (sqrt(pi) ^ 2.0)))); elseif (Float64(angle / 180.0) <= 5e+199) tmp = Float64(t_0 * t_0) ^ -0.5; else tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(Float64(sqrt(pi) / 180.0) * Float64(angle * sqrt(pi))))))) * cos(Float64(Float64(pi * angle) * 0.005555555555555556))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / sin((0.011111111111111112 * (pi * angle))); tmp = 0.0; if ((angle / 180.0) <= 5e+66) tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((pi / (180.0 / angle)))))) * cos(((angle / 180.0) * (sqrt(pi) ^ 2.0))); elseif ((angle / 180.0) <= 5e+199) tmp = (t_0 * t_0) ^ -0.5; else tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin(((sqrt(pi) / 180.0) * (angle * sqrt(pi))))))) * cos(((pi * angle) * 0.005555555555555556)); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(N[(N[(1.0 / N[(b$95$m - a), $MachinePrecision]), $MachinePrecision] / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision] / N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(angle / 180.0), $MachinePrecision] * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+199], N[Power[N[(t$95$0 * t$95$0), $MachinePrecision], -0.5], $MachinePrecision], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[Sqrt[Pi], $MachinePrecision] / 180.0), $MachinePrecision] * N[(angle * N[Sqrt[Pi], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(Pi * angle), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \frac{\frac{\frac{1}{b\_m - a}}{b\_m + a}}{\sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)}\\
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(\frac{angle}{180} \cdot {\left(\sqrt{\pi}\right)}^{2}\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 5 \cdot 10^{+199}:\\
\;\;\;\;{\left(t\_0 \cdot t\_0\right)}^{-0.5}\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt{\pi}}{180} \cdot \left(angle \cdot \sqrt{\pi}\right)\right)\right)\right)\right) \cdot \cos \left(\left(\pi \cdot angle\right) \cdot 0.005555555555555556\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-sqr-sqrtN/A
pow2N/A
pow-lowering-pow.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f6476.3%
Applied egg-rr76.3%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 4.9999999999999998e199Initial program 32.9%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6430.1%
Applied egg-rr30.1%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6424.9%
Applied egg-rr24.9%
Applied egg-rr42.2%
if 4.9999999999999998e199 < (/.f64 angle #s(literal 180 binary64)) Initial program 37.0%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6437.8%
Applied egg-rr37.8%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6437.4%
Applied egg-rr37.4%
associate-/r/N/A
/-rgt-identityN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f6436.5%
Applied egg-rr36.5%
Taylor expanded in angle around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
cos-lowering-cos.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6443.5%
Simplified43.5%
Final simplification69.3%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (* PI (/ angle 180.0)))
(t_1
(/
(/ (/ 1.0 (- b_m a)) (+ b_m a))
(sin (* 0.011111111111111112 (* PI angle))))))
(if (<= (/ angle 180.0) 5e+66)
(*
(* (- b_m a) (* (+ b_m a) (* 2.0 (sin (/ PI (/ 180.0 angle))))))
(cos (* (/ angle 180.0) (pow (sqrt PI) 2.0))))
(if (<= (/ angle 180.0) 1e+194)
(pow (* t_1 t_1) -0.5)
(*
(/ 2.0 (* (pow (* (- b_m a) (- b_m a)) -0.5) (/ 1.0 (+ b_m a))))
(* (sin t_0) (cos t_0)))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
double t_1 = ((1.0 / (b_m - a)) / (b_m + a)) / sin((0.011111111111111112 * (((double) M_PI) * angle)));
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((((double) M_PI) / (180.0 / angle)))))) * cos(((angle / 180.0) * pow(sqrt(((double) M_PI)), 2.0)));
} else if ((angle / 180.0) <= 1e+194) {
tmp = pow((t_1 * t_1), -0.5);
} else {
tmp = (2.0 / (pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (sin(t_0) * cos(t_0));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.PI * (angle / 180.0);
double t_1 = ((1.0 / (b_m - a)) / (b_m + a)) / Math.sin((0.011111111111111112 * (Math.PI * angle)));
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.PI / (180.0 / angle)))))) * Math.cos(((angle / 180.0) * Math.pow(Math.sqrt(Math.PI), 2.0)));
} else if ((angle / 180.0) <= 1e+194) {
tmp = Math.pow((t_1 * t_1), -0.5);
} else {
tmp = (2.0 / (Math.pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (Math.sin(t_0) * Math.cos(t_0));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): t_0 = math.pi * (angle / 180.0) t_1 = ((1.0 / (b_m - a)) / (b_m + a)) / math.sin((0.011111111111111112 * (math.pi * angle))) tmp = 0 if (angle / 180.0) <= 5e+66: tmp = ((b_m - a) * ((b_m + a) * (2.0 * math.sin((math.pi / (180.0 / angle)))))) * math.cos(((angle / 180.0) * math.pow(math.sqrt(math.pi), 2.0))) elif (angle / 180.0) <= 1e+194: tmp = math.pow((t_1 * t_1), -0.5) else: tmp = (2.0 / (math.pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (math.sin(t_0) * math.cos(t_0)) return tmp
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(pi * Float64(angle / 180.0)) t_1 = Float64(Float64(Float64(1.0 / Float64(b_m - a)) / Float64(b_m + a)) / sin(Float64(0.011111111111111112 * Float64(pi * angle)))) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle)))))) * cos(Float64(Float64(angle / 180.0) * (sqrt(pi) ^ 2.0)))); elseif (Float64(angle / 180.0) <= 1e+194) tmp = Float64(t_1 * t_1) ^ -0.5; else tmp = Float64(Float64(2.0 / Float64((Float64(Float64(b_m - a) * Float64(b_m - a)) ^ -0.5) * Float64(1.0 / Float64(b_m + a)))) * Float64(sin(t_0) * cos(t_0))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) t_0 = pi * (angle / 180.0); t_1 = ((1.0 / (b_m - a)) / (b_m + a)) / sin((0.011111111111111112 * (pi * angle))); tmp = 0.0; if ((angle / 180.0) <= 5e+66) tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((pi / (180.0 / angle)))))) * cos(((angle / 180.0) * (sqrt(pi) ^ 2.0))); elseif ((angle / 180.0) <= 1e+194) tmp = (t_1 * t_1) ^ -0.5; else tmp = (2.0 / ((((b_m - a) * (b_m - a)) ^ -0.5) * (1.0 / (b_m + a)))) * (sin(t_0) * cos(t_0)); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(1.0 / N[(b$95$m - a), $MachinePrecision]), $MachinePrecision] / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision] / N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(angle / 180.0), $MachinePrecision] * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+194], N[Power[N[(t$95$1 * t$95$1), $MachinePrecision], -0.5], $MachinePrecision], N[(N[(2.0 / N[(N[Power[N[(N[(b$95$m - a), $MachinePrecision] * N[(b$95$m - a), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[(1.0 / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[t$95$0], $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
t_1 := \frac{\frac{\frac{1}{b\_m - a}}{b\_m + a}}{\sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)}\\
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(\frac{angle}{180} \cdot {\left(\sqrt{\pi}\right)}^{2}\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+194}:\\
\;\;\;\;{\left(t\_1 \cdot t\_1\right)}^{-0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\left(b\_m - a\right) \cdot \left(b\_m - a\right)\right)}^{-0.5} \cdot \frac{1}{b\_m + a}} \cdot \left(\sin t\_0 \cdot \cos t\_0\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-sqr-sqrtN/A
pow2N/A
pow-lowering-pow.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f6476.3%
Applied egg-rr76.3%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999945e193Initial program 32.7%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6429.7%
Applied egg-rr29.7%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6424.0%
Applied egg-rr24.0%
Applied egg-rr42.5%
if 9.99999999999999945e193 < (/.f64 angle #s(literal 180 binary64)) Initial program 36.6%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6436.6%
Simplified36.6%
flip--N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
inv-powN/A
difference-of-squaresN/A
*-commutativeN/A
unpow-prod-downN/A
inv-powN/A
inv-powN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6436.6%
Applied egg-rr36.6%
inv-powN/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
metadata-eval38.8%
Applied egg-rr38.8%
Final simplification69.0%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0
(/
(/ (/ 1.0 (- b_m a)) (+ b_m a))
(sin (* 0.011111111111111112 (* PI angle)))))
(t_1 (* PI (/ angle 180.0)))
(t_2 (cos t_1)))
(if (<= (/ angle 180.0) 5e+66)
(*
(*
(- b_m a)
(* (+ b_m a) (* 2.0 (sin (/ (cbrt (* PI (* PI PI))) (/ 180.0 angle))))))
t_2)
(if (<= (/ angle 180.0) 1e+194)
(pow (* t_0 t_0) -0.5)
(*
(/ 2.0 (* (pow (* (- b_m a) (- b_m a)) -0.5) (/ 1.0 (+ b_m a))))
(* (sin t_1) t_2))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / sin((0.011111111111111112 * (((double) M_PI) * angle)));
double t_1 = ((double) M_PI) * (angle / 180.0);
double t_2 = cos(t_1);
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((cbrt((((double) M_PI) * (((double) M_PI) * ((double) M_PI)))) / (180.0 / angle)))))) * t_2;
} else if ((angle / 180.0) <= 1e+194) {
tmp = pow((t_0 * t_0), -0.5);
} else {
tmp = (2.0 / (pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (sin(t_1) * t_2);
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = ((1.0 / (b_m - a)) / (b_m + a)) / Math.sin((0.011111111111111112 * (Math.PI * angle)));
double t_1 = Math.PI * (angle / 180.0);
double t_2 = Math.cos(t_1);
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.cbrt((Math.PI * (Math.PI * Math.PI))) / (180.0 / angle)))))) * t_2;
} else if ((angle / 180.0) <= 1e+194) {
tmp = Math.pow((t_0 * t_0), -0.5);
} else {
tmp = (2.0 / (Math.pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (Math.sin(t_1) * t_2);
}
return tmp;
}
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(Float64(Float64(1.0 / Float64(b_m - a)) / Float64(b_m + a)) / sin(Float64(0.011111111111111112 * Float64(pi * angle)))) t_1 = Float64(pi * Float64(angle / 180.0)) t_2 = cos(t_1) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(cbrt(Float64(pi * Float64(pi * pi))) / Float64(180.0 / angle)))))) * t_2); elseif (Float64(angle / 180.0) <= 1e+194) tmp = Float64(t_0 * t_0) ^ -0.5; else tmp = Float64(Float64(2.0 / Float64((Float64(Float64(b_m - a) * Float64(b_m - a)) ^ -0.5) * Float64(1.0 / Float64(b_m + a)))) * Float64(sin(t_1) * t_2)); end return tmp end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(N[(N[(1.0 / N[(b$95$m - a), $MachinePrecision]), $MachinePrecision] / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision] / N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Cos[t$95$1], $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+194], N[Power[N[(t$95$0 * t$95$0), $MachinePrecision], -0.5], $MachinePrecision], N[(N[(2.0 / N[(N[Power[N[(N[(b$95$m - a), $MachinePrecision] * N[(b$95$m - a), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[(1.0 / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[t$95$1], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \frac{\frac{\frac{1}{b\_m - a}}{b\_m + a}}{\sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)}\\
t_1 := \pi \cdot \frac{angle}{180}\\
t_2 := \cos t\_1\\
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt[3]{\pi \cdot \left(\pi \cdot \pi\right)}}{\frac{180}{angle}}\right)\right)\right)\right) \cdot t\_2\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+194}:\\
\;\;\;\;{\left(t\_0 \cdot t\_0\right)}^{-0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\left(b\_m - a\right) \cdot \left(b\_m - a\right)\right)}^{-0.5} \cdot \frac{1}{b\_m + a}} \cdot \left(\sin t\_1 \cdot t\_2\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-cbrt-cubeN/A
cbrt-lowering-cbrt.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6475.2%
Applied egg-rr75.2%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 9.99999999999999945e193Initial program 32.7%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6429.7%
Applied egg-rr29.7%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6424.0%
Applied egg-rr24.0%
Applied egg-rr42.5%
if 9.99999999999999945e193 < (/.f64 angle #s(literal 180 binary64)) Initial program 36.6%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6436.6%
Simplified36.6%
flip--N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
inv-powN/A
difference-of-squaresN/A
*-commutativeN/A
unpow-prod-downN/A
inv-powN/A
inv-powN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6436.6%
Applied egg-rr36.6%
inv-powN/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
metadata-eval38.8%
Applied egg-rr38.8%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (* PI (/ angle 180.0))))
(if (<= (/ angle 180.0) 1e+167)
(*
(*
(- b_m a)
(* (+ b_m a) (* 2.0 (sin (/ (cbrt (* PI (* PI PI))) (/ 180.0 angle))))))
(cos (/ PI (/ 180.0 angle))))
(*
(/ 2.0 (* (pow (* (- b_m a) (- b_m a)) -0.5) (/ 1.0 (+ b_m a))))
(* (sin t_0) (cos t_0))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
double tmp;
if ((angle / 180.0) <= 1e+167) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((cbrt((((double) M_PI) * (((double) M_PI) * ((double) M_PI)))) / (180.0 / angle)))))) * cos((((double) M_PI) / (180.0 / angle)));
} else {
tmp = (2.0 / (pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (sin(t_0) * cos(t_0));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.PI * (angle / 180.0);
double tmp;
if ((angle / 180.0) <= 1e+167) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.cbrt((Math.PI * (Math.PI * Math.PI))) / (180.0 / angle)))))) * Math.cos((Math.PI / (180.0 / angle)));
} else {
tmp = (2.0 / (Math.pow(((b_m - a) * (b_m - a)), -0.5) * (1.0 / (b_m + a)))) * (Math.sin(t_0) * Math.cos(t_0));
}
return tmp;
}
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(pi * Float64(angle / 180.0)) tmp = 0.0 if (Float64(angle / 180.0) <= 1e+167) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(cbrt(Float64(pi * Float64(pi * pi))) / Float64(180.0 / angle)))))) * cos(Float64(pi / Float64(180.0 / angle)))); else tmp = Float64(Float64(2.0 / Float64((Float64(Float64(b_m - a) * Float64(b_m - a)) ^ -0.5) * Float64(1.0 / Float64(b_m + a)))) * Float64(sin(t_0) * cos(t_0))); end return tmp end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+167], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Power[N[(N[(b$95$m - a), $MachinePrecision] * N[(b$95$m - a), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[(1.0 / N[(b$95$m + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[t$95$0], $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\mathbf{if}\;\frac{angle}{180} \leq 10^{+167}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt[3]{\pi \cdot \left(\pi \cdot \pi\right)}}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(\frac{\pi}{\frac{180}{angle}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\left(b\_m - a\right) \cdot \left(b\_m - a\right)\right)}^{-0.5} \cdot \frac{1}{b\_m + a}} \cdot \left(\sin t\_0 \cdot \cos t\_0\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1e167Initial program 60.8%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6471.3%
Applied egg-rr71.3%
add-cbrt-cubeN/A
cbrt-lowering-cbrt.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6471.9%
Applied egg-rr71.9%
clear-numN/A
div-invN/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6472.8%
Applied egg-rr72.8%
if 1e167 < (/.f64 angle #s(literal 180 binary64)) Initial program 32.3%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6432.3%
Simplified32.3%
flip--N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6432.3%
Applied egg-rr32.3%
inv-powN/A
difference-of-squaresN/A
*-commutativeN/A
unpow-prod-downN/A
inv-powN/A
inv-powN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6432.3%
Applied egg-rr32.3%
inv-powN/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
metadata-eval35.6%
Applied egg-rr35.6%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (* PI (* PI PI))))
(if (<= (/ angle 180.0) 1e+106)
(*
(* (- b_m a) (* (+ b_m a) (* 2.0 (sin (/ (cbrt t_0) (/ 180.0 angle))))))
(cos (/ PI (/ 180.0 angle))))
(*
(- b_m a)
(*
(+ b_m a)
(*
2.0
(sin (/ (pow (* t_0 t_0) 0.16666666666666666) (/ 180.0 angle)))))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((double) M_PI) * (((double) M_PI) * ((double) M_PI));
double tmp;
if ((angle / 180.0) <= 1e+106) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((cbrt(t_0) / (180.0 / angle)))))) * cos((((double) M_PI) / (180.0 / angle)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * sin((pow((t_0 * t_0), 0.16666666666666666) / (180.0 / angle)))));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.PI * (Math.PI * Math.PI);
double tmp;
if ((angle / 180.0) <= 1e+106) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.cbrt(t_0) / (180.0 / angle)))))) * Math.cos((Math.PI / (180.0 / angle)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.pow((t_0 * t_0), 0.16666666666666666) / (180.0 / angle)))));
}
return tmp;
}
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(pi * Float64(pi * pi)) tmp = 0.0 if (Float64(angle / 180.0) <= 1e+106) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(cbrt(t_0) / Float64(180.0 / angle)))))) * cos(Float64(pi / Float64(180.0 / angle)))); else tmp = Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64((Float64(t_0 * t_0) ^ 0.16666666666666666) / Float64(180.0 / angle)))))); end return tmp end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+106], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[t$95$0, 1/3], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(t$95$0 * t$95$0), $MachinePrecision], 0.16666666666666666], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(\pi \cdot \pi\right)\\
\mathbf{if}\;\frac{angle}{180} \leq 10^{+106}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt[3]{t\_0}}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(\frac{\pi}{\frac{180}{angle}}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{{\left(t\_0 \cdot t\_0\right)}^{0.16666666666666666}}{\frac{180}{angle}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.00000000000000009e106Initial program 62.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6474.0%
Applied egg-rr74.0%
add-cbrt-cubeN/A
cbrt-lowering-cbrt.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6474.4%
Applied egg-rr74.4%
clear-numN/A
div-invN/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.6%
Applied egg-rr75.6%
if 1.00000000000000009e106 < (/.f64 angle #s(literal 180 binary64)) Initial program 34.5%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6432.8%
Applied egg-rr32.8%
Taylor expanded in angle around 0
Simplified35.4%
rem-cbrt-cubeN/A
cube-unmultN/A
pow1/3N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
pow-prod-upN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
Applied egg-rr37.6%
Final simplification68.8%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(if (<= (/ angle 180.0) 5e+66)
(*
(*
(- b_m a)
(* (+ b_m a) (* 2.0 (sin (/ (cbrt (* PI (* PI PI))) (/ 180.0 angle))))))
(cos (* PI (/ angle 180.0))))
(if (<= (/ angle 180.0) 2e+191)
(pow
(pow
(* (- b_m a) (* (+ b_m a) (sin (* 0.011111111111111112 (* PI angle)))))
0.5)
2.0)
(* (- b_m a) (* (sin (/ PI (/ 180.0 angle))) (* (+ b_m a) 2.0))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * sin((cbrt((((double) M_PI) * (((double) M_PI) * ((double) M_PI)))) / (180.0 / angle)))))) * cos((((double) M_PI) * (angle / 180.0)));
} else if ((angle / 180.0) <= 2e+191) {
tmp = pow(pow(((b_m - a) * ((b_m + a) * sin((0.011111111111111112 * (((double) M_PI) * angle))))), 0.5), 2.0);
} else {
tmp = (b_m - a) * (sin((((double) M_PI) / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = ((b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.cbrt((Math.PI * (Math.PI * Math.PI))) / (180.0 / angle)))))) * Math.cos((Math.PI * (angle / 180.0)));
} else if ((angle / 180.0) <= 2e+191) {
tmp = Math.pow(Math.pow(((b_m - a) * ((b_m + a) * Math.sin((0.011111111111111112 * (Math.PI * angle))))), 0.5), 2.0);
} else {
tmp = (b_m - a) * (Math.sin((Math.PI / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64(cbrt(Float64(pi * Float64(pi * pi))) / Float64(180.0 / angle)))))) * cos(Float64(pi * Float64(angle / 180.0)))); elseif (Float64(angle / 180.0) <= 2e+191) tmp = (Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * sin(Float64(0.011111111111111112 * Float64(pi * angle))))) ^ 0.5) ^ 2.0; else tmp = Float64(Float64(b_m - a) * Float64(sin(Float64(pi / Float64(180.0 / angle))) * Float64(Float64(b_m + a) * 2.0))); end return tmp end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+191], N[Power[N[Power[N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], 2.0], $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{\sqrt[3]{\pi \cdot \left(\pi \cdot \pi\right)}}{\frac{180}{angle}}\right)\right)\right)\right) \cdot \cos \left(\pi \cdot \frac{angle}{180}\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 2 \cdot 10^{+191}:\\
\;\;\;\;{\left({\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)\right)\right)}^{0.5}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\sin \left(\frac{\pi}{\frac{180}{angle}}\right) \cdot \left(\left(b\_m + a\right) \cdot 2\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-cbrt-cubeN/A
cbrt-lowering-cbrt.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6475.2%
Applied egg-rr75.2%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000015e191Initial program 35.3%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6432.0%
Applied egg-rr32.0%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6425.5%
Applied egg-rr25.5%
Applied egg-rr43.8%
if 2.00000000000000015e191 < (/.f64 angle #s(literal 180 binary64)) Initial program 33.2%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6433.9%
Applied egg-rr33.9%
Taylor expanded in angle around 0
Simplified41.2%
*-rgt-identityN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6441.2%
Applied egg-rr41.2%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (sin (* 0.011111111111111112 (* PI angle)))))
(if (<= (/ angle 180.0) 2e+49)
(* (+ b_m a) (* (- b_m a) t_0))
(if (<= (/ angle 180.0) 2e+191)
(pow (pow (* (- b_m a) (* (+ b_m a) t_0)) 0.5) 2.0)
(* (- b_m a) (* (sin (/ PI (/ 180.0 angle))) (* (+ b_m a) 2.0)))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = sin((0.011111111111111112 * (((double) M_PI) * angle)));
double tmp;
if ((angle / 180.0) <= 2e+49) {
tmp = (b_m + a) * ((b_m - a) * t_0);
} else if ((angle / 180.0) <= 2e+191) {
tmp = pow(pow(((b_m - a) * ((b_m + a) * t_0)), 0.5), 2.0);
} else {
tmp = (b_m - a) * (sin((((double) M_PI) / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.sin((0.011111111111111112 * (Math.PI * angle)));
double tmp;
if ((angle / 180.0) <= 2e+49) {
tmp = (b_m + a) * ((b_m - a) * t_0);
} else if ((angle / 180.0) <= 2e+191) {
tmp = Math.pow(Math.pow(((b_m - a) * ((b_m + a) * t_0)), 0.5), 2.0);
} else {
tmp = (b_m - a) * (Math.sin((Math.PI / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): t_0 = math.sin((0.011111111111111112 * (math.pi * angle))) tmp = 0 if (angle / 180.0) <= 2e+49: tmp = (b_m + a) * ((b_m - a) * t_0) elif (angle / 180.0) <= 2e+191: tmp = math.pow(math.pow(((b_m - a) * ((b_m + a) * t_0)), 0.5), 2.0) else: tmp = (b_m - a) * (math.sin((math.pi / (180.0 / angle))) * ((b_m + a) * 2.0)) return tmp
b_m = abs(b) function code(a, b_m, angle) t_0 = sin(Float64(0.011111111111111112 * Float64(pi * angle))) tmp = 0.0 if (Float64(angle / 180.0) <= 2e+49) tmp = Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * t_0)); elseif (Float64(angle / 180.0) <= 2e+191) tmp = (Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * t_0)) ^ 0.5) ^ 2.0; else tmp = Float64(Float64(b_m - a) * Float64(sin(Float64(pi / Float64(180.0 / angle))) * Float64(Float64(b_m + a) * 2.0))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) t_0 = sin((0.011111111111111112 * (pi * angle))); tmp = 0.0; if ((angle / 180.0) <= 2e+49) tmp = (b_m + a) * ((b_m - a) * t_0); elseif ((angle / 180.0) <= 2e+191) tmp = (((b_m - a) * ((b_m + a) * t_0)) ^ 0.5) ^ 2.0; else tmp = (b_m - a) * (sin((pi / (180.0 / angle))) * ((b_m + a) * 2.0)); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+49], N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+191], N[Power[N[Power[N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], 2.0], $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)\\
\mathbf{if}\;\frac{angle}{180} \leq 2 \cdot 10^{+49}:\\
\;\;\;\;\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot t\_0\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 2 \cdot 10^{+191}:\\
\;\;\;\;{\left({\left(\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot t\_0\right)\right)}^{0.5}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\sin \left(\frac{\pi}{\frac{180}{angle}}\right) \cdot \left(\left(b\_m + a\right) \cdot 2\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.99999999999999989e49Initial program 63.7%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6477.5%
Applied egg-rr77.5%
Applied egg-rr75.1%
if 1.99999999999999989e49 < (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000015e191Initial program 37.1%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6437.4%
Applied egg-rr37.4%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6434.8%
Applied egg-rr34.8%
Applied egg-rr50.8%
if 2.00000000000000015e191 < (/.f64 angle #s(literal 180 binary64)) Initial program 33.2%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6433.9%
Applied egg-rr33.9%
Taylor expanded in angle around 0
Simplified41.2%
*-rgt-identityN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6441.2%
Applied egg-rr41.2%
Final simplification68.8%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(let* ((t_0 (* PI (* PI PI))))
(if (<= (/ angle 180.0) 5e+66)
(* (+ b_m a) (* (- b_m a) (sin (* 0.011111111111111112 (* PI angle)))))
(if (<= (/ angle 180.0) 1e+84)
(* 0.011111111111111112 (* angle (* PI (* b_m b_m))))
(*
(- b_m a)
(*
(+ b_m a)
(*
2.0
(sin
(/ (pow (* t_0 t_0) 0.16666666666666666) (/ 180.0 angle))))))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double t_0 = ((double) M_PI) * (((double) M_PI) * ((double) M_PI));
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (((double) M_PI) * angle))));
} else if ((angle / 180.0) <= 1e+84) {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * b_m)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * sin((pow((t_0 * t_0), 0.16666666666666666) / (180.0 / angle)))));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double t_0 = Math.PI * (Math.PI * Math.PI);
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = (b_m + a) * ((b_m - a) * Math.sin((0.011111111111111112 * (Math.PI * angle))));
} else if ((angle / 180.0) <= 1e+84) {
tmp = 0.011111111111111112 * (angle * (Math.PI * (b_m * b_m)));
} else {
tmp = (b_m - a) * ((b_m + a) * (2.0 * Math.sin((Math.pow((t_0 * t_0), 0.16666666666666666) / (180.0 / angle)))));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): t_0 = math.pi * (math.pi * math.pi) tmp = 0 if (angle / 180.0) <= 5e+66: tmp = (b_m + a) * ((b_m - a) * math.sin((0.011111111111111112 * (math.pi * angle)))) elif (angle / 180.0) <= 1e+84: tmp = 0.011111111111111112 * (angle * (math.pi * (b_m * b_m))) else: tmp = (b_m - a) * ((b_m + a) * (2.0 * math.sin((math.pow((t_0 * t_0), 0.16666666666666666) / (180.0 / angle))))) return tmp
b_m = abs(b) function code(a, b_m, angle) t_0 = Float64(pi * Float64(pi * pi)) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * sin(Float64(0.011111111111111112 * Float64(pi * angle))))); elseif (Float64(angle / 180.0) <= 1e+84) tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * b_m)))); else tmp = Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * sin(Float64((Float64(t_0 * t_0) ^ 0.16666666666666666) / Float64(180.0 / angle)))))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) t_0 = pi * (pi * pi); tmp = 0.0; if ((angle / 180.0) <= 5e+66) tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (pi * angle)))); elseif ((angle / 180.0) <= 1e+84) tmp = 0.011111111111111112 * (angle * (pi * (b_m * b_m))); else tmp = (b_m - a) * ((b_m + a) * (2.0 * sin((((t_0 * t_0) ^ 0.16666666666666666) / (180.0 / angle))))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision]
code[a_, b$95$m_, angle_] := Block[{t$95$0 = N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+84], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[Power[N[(t$95$0 * t$95$0), $MachinePrecision], 0.16666666666666666], $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(\pi \cdot \pi\right)\\
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot \sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+84}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot b\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \sin \left(\frac{{\left(t\_0 \cdot t\_0\right)}^{0.16666666666666666}}{\frac{180}{angle}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6477.9%
Applied egg-rr77.9%
Applied egg-rr75.1%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 1.00000000000000006e84Initial program 33.3%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6433.3%
Simplified33.3%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
if 1.00000000000000006e84 < (/.f64 angle #s(literal 180 binary64)) Initial program 34.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6432.9%
Applied egg-rr32.9%
Taylor expanded in angle around 0
Simplified32.9%
rem-cbrt-cubeN/A
cube-unmultN/A
pow1/3N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
pow-prod-upN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
Applied egg-rr35.3%
Final simplification67.6%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(if (<= (/ angle 180.0) 5e+66)
(* (+ b_m a) (* (- b_m a) (sin (* 0.011111111111111112 (* PI angle)))))
(if (<= (/ angle 180.0) 1e+78)
(* 0.011111111111111112 (* angle (* PI (* b_m b_m))))
(* (- b_m a) (* (sin (/ PI (/ 180.0 angle))) (* (+ b_m a) 2.0))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (((double) M_PI) * angle))));
} else if ((angle / 180.0) <= 1e+78) {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * b_m)));
} else {
tmp = (b_m - a) * (sin((((double) M_PI) / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if ((angle / 180.0) <= 5e+66) {
tmp = (b_m + a) * ((b_m - a) * Math.sin((0.011111111111111112 * (Math.PI * angle))));
} else if ((angle / 180.0) <= 1e+78) {
tmp = 0.011111111111111112 * (angle * (Math.PI * (b_m * b_m)));
} else {
tmp = (b_m - a) * (Math.sin((Math.PI / (180.0 / angle))) * ((b_m + a) * 2.0));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if (angle / 180.0) <= 5e+66: tmp = (b_m + a) * ((b_m - a) * math.sin((0.011111111111111112 * (math.pi * angle)))) elif (angle / 180.0) <= 1e+78: tmp = 0.011111111111111112 * (angle * (math.pi * (b_m * b_m))) else: tmp = (b_m - a) * (math.sin((math.pi / (180.0 / angle))) * ((b_m + a) * 2.0)) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 5e+66) tmp = Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * sin(Float64(0.011111111111111112 * Float64(pi * angle))))); elseif (Float64(angle / 180.0) <= 1e+78) tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * b_m)))); else tmp = Float64(Float64(b_m - a) * Float64(sin(Float64(pi / Float64(180.0 / angle))) * Float64(Float64(b_m + a) * 2.0))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if ((angle / 180.0) <= 5e+66) tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (pi * angle)))); elseif ((angle / 180.0) <= 1e+78) tmp = 0.011111111111111112 * (angle * (pi * (b_m * b_m))); else tmp = (b_m - a) * (sin((pi / (180.0 / angle))) * ((b_m + a) * 2.0)); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+66], N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+78], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[Sin[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 5 \cdot 10^{+66}:\\
\;\;\;\;\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot \sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+78}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot b\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\sin \left(\frac{\pi}{\frac{180}{angle}}\right) \cdot \left(\left(b\_m + a\right) \cdot 2\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 4.99999999999999991e66Initial program 63.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6475.4%
Applied egg-rr75.4%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6477.9%
Applied egg-rr77.9%
Applied egg-rr75.1%
if 4.99999999999999991e66 < (/.f64 angle #s(literal 180 binary64)) < 1.00000000000000001e78Initial program 33.3%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6433.3%
Simplified33.3%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
if 1.00000000000000001e78 < (/.f64 angle #s(literal 180 binary64)) Initial program 34.4%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6432.9%
Applied egg-rr32.9%
Taylor expanded in angle around 0
Simplified32.9%
*-rgt-identityN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6432.9%
Applied egg-rr32.9%
Final simplification67.1%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(if (<= a 1.1e+177)
(* (+ b_m a) (* (- b_m a) (sin (* 0.011111111111111112 (* PI angle)))))
(*
(- b_m a)
(*
angle
(+
(* 0.011111111111111112 (* (+ b_m a) PI))
(*
(* angle angle)
(* (+ b_m a) (* (* PI (* PI PI)) -5.7155921353452215e-8))))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (a <= 1.1e+177) {
tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (((double) M_PI) * angle))));
} else {
tmp = (b_m - a) * (angle * ((0.011111111111111112 * ((b_m + a) * ((double) M_PI))) + ((angle * angle) * ((b_m + a) * ((((double) M_PI) * (((double) M_PI) * ((double) M_PI))) * -5.7155921353452215e-8)))));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (a <= 1.1e+177) {
tmp = (b_m + a) * ((b_m - a) * Math.sin((0.011111111111111112 * (Math.PI * angle))));
} else {
tmp = (b_m - a) * (angle * ((0.011111111111111112 * ((b_m + a) * Math.PI)) + ((angle * angle) * ((b_m + a) * ((Math.PI * (Math.PI * Math.PI)) * -5.7155921353452215e-8)))));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if a <= 1.1e+177: tmp = (b_m + a) * ((b_m - a) * math.sin((0.011111111111111112 * (math.pi * angle)))) else: tmp = (b_m - a) * (angle * ((0.011111111111111112 * ((b_m + a) * math.pi)) + ((angle * angle) * ((b_m + a) * ((math.pi * (math.pi * math.pi)) * -5.7155921353452215e-8))))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (a <= 1.1e+177) tmp = Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * sin(Float64(0.011111111111111112 * Float64(pi * angle))))); else tmp = Float64(Float64(b_m - a) * Float64(angle * Float64(Float64(0.011111111111111112 * Float64(Float64(b_m + a) * pi)) + Float64(Float64(angle * angle) * Float64(Float64(b_m + a) * Float64(Float64(pi * Float64(pi * pi)) * -5.7155921353452215e-8)))))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (a <= 1.1e+177) tmp = (b_m + a) * ((b_m - a) * sin((0.011111111111111112 * (pi * angle)))); else tmp = (b_m - a) * (angle * ((0.011111111111111112 * ((b_m + a) * pi)) + ((angle * angle) * ((b_m + a) * ((pi * (pi * pi)) * -5.7155921353452215e-8))))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[a, 1.1e+177], N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m - a), $MachinePrecision] * N[(angle * N[(N[(0.011111111111111112 * N[(N[(b$95$m + a), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] + N[(N[(angle * angle), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] * -5.7155921353452215e-8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.1 \cdot 10^{+177}:\\
\;\;\;\;\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot \sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(angle \cdot \left(0.011111111111111112 \cdot \left(\left(b\_m + a\right) \cdot \pi\right) + \left(angle \cdot angle\right) \cdot \left(\left(b\_m + a\right) \cdot \left(\left(\pi \cdot \left(\pi \cdot \pi\right)\right) \cdot -5.7155921353452215 \cdot 10^{-8}\right)\right)\right)\right)\\
\end{array}
\end{array}
if a < 1.0999999999999999e177Initial program 59.2%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6466.5%
Applied egg-rr66.5%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6467.9%
Applied egg-rr67.9%
Applied egg-rr65.7%
if 1.0999999999999999e177 < a Initial program 37.5%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6468.2%
Applied egg-rr68.2%
Taylor expanded in angle around 0
Simplified77.3%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
+-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-commutativeN/A
Simplified77.2%
Final simplification66.7%
b_m = (fabs.f64 b)
(FPCore (a b_m angle)
:precision binary64
(if (<= angle 4.3e+27)
(*
(- b_m a)
(*
(+ b_m a)
(*
2.0
(*
angle
(+
(* PI 0.005555555555555556)
(* (* angle angle) (* (* PI PI) (* PI -2.8577960676726107e-8))))))))
(/ 1.0 (/ (/ 90.0 angle) (* (+ b_m a) (* (- b_m a) PI))))))b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 4.3e+27) {
tmp = (b_m - a) * ((b_m + a) * (2.0 * (angle * ((((double) M_PI) * 0.005555555555555556) + ((angle * angle) * ((((double) M_PI) * ((double) M_PI)) * (((double) M_PI) * -2.8577960676726107e-8)))))));
} else {
tmp = 1.0 / ((90.0 / angle) / ((b_m + a) * ((b_m - a) * ((double) M_PI))));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 4.3e+27) {
tmp = (b_m - a) * ((b_m + a) * (2.0 * (angle * ((Math.PI * 0.005555555555555556) + ((angle * angle) * ((Math.PI * Math.PI) * (Math.PI * -2.8577960676726107e-8)))))));
} else {
tmp = 1.0 / ((90.0 / angle) / ((b_m + a) * ((b_m - a) * Math.PI)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if angle <= 4.3e+27: tmp = (b_m - a) * ((b_m + a) * (2.0 * (angle * ((math.pi * 0.005555555555555556) + ((angle * angle) * ((math.pi * math.pi) * (math.pi * -2.8577960676726107e-8))))))) else: tmp = 1.0 / ((90.0 / angle) / ((b_m + a) * ((b_m - a) * math.pi))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (angle <= 4.3e+27) tmp = Float64(Float64(b_m - a) * Float64(Float64(b_m + a) * Float64(2.0 * Float64(angle * Float64(Float64(pi * 0.005555555555555556) + Float64(Float64(angle * angle) * Float64(Float64(pi * pi) * Float64(pi * -2.8577960676726107e-8)))))))); else tmp = Float64(1.0 / Float64(Float64(90.0 / angle) / Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * pi)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (angle <= 4.3e+27) tmp = (b_m - a) * ((b_m + a) * (2.0 * (angle * ((pi * 0.005555555555555556) + ((angle * angle) * ((pi * pi) * (pi * -2.8577960676726107e-8))))))); else tmp = 1.0 / ((90.0 / angle) / ((b_m + a) * ((b_m - a) * pi))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[angle, 4.3e+27], N[(N[(b$95$m - a), $MachinePrecision] * N[(N[(b$95$m + a), $MachinePrecision] * N[(2.0 * N[(angle * N[(N[(Pi * 0.005555555555555556), $MachinePrecision] + N[(N[(angle * angle), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * N[(Pi * -2.8577960676726107e-8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(90.0 / angle), $MachinePrecision] / N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 4.3 \cdot 10^{+27}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(\left(b\_m + a\right) \cdot \left(2 \cdot \left(angle \cdot \left(\pi \cdot 0.005555555555555556 + \left(angle \cdot angle\right) \cdot \left(\left(\pi \cdot \pi\right) \cdot \left(\pi \cdot -2.8577960676726107 \cdot 10^{-8}\right)\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\frac{90}{angle}}{\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot \pi\right)}}\\
\end{array}
\end{array}
if angle < 4.30000000000000008e27Initial program 65.5%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6477.7%
Applied egg-rr77.7%
Taylor expanded in angle around 0
Simplified76.5%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
associate-*r*N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow3N/A
unpow2N/A
Simplified74.5%
if 4.30000000000000008e27 < angle Initial program 33.6%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6433.9%
Applied egg-rr33.9%
associate-*r*N/A
div-invN/A
clear-numN/A
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
*-commutativeN/A
metadata-evalN/A
associate-/r/N/A
associate-*r*N/A
Applied egg-rr35.6%
div-invN/A
clear-numN/A
count-2N/A
clear-numN/A
div-invN/A
clear-numN/A
clear-numN/A
div-invN/A
frac-addN/A
/-lowering-/.f64N/A
Applied egg-rr17.9%
Taylor expanded in angle around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f6433.9%
Simplified33.9%
Final simplification64.1%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= angle 2.55e+182) (* (- b_m a) (* angle (* 0.011111111111111112 (* (+ b_m a) PI)))) (* 0.011111111111111112 (* angle (* PI (* b_m b_m))))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 2.55e+182) {
tmp = (b_m - a) * (angle * (0.011111111111111112 * ((b_m + a) * ((double) M_PI))));
} else {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * b_m)));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 2.55e+182) {
tmp = (b_m - a) * (angle * (0.011111111111111112 * ((b_m + a) * Math.PI)));
} else {
tmp = 0.011111111111111112 * (angle * (Math.PI * (b_m * b_m)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if angle <= 2.55e+182: tmp = (b_m - a) * (angle * (0.011111111111111112 * ((b_m + a) * math.pi))) else: tmp = 0.011111111111111112 * (angle * (math.pi * (b_m * b_m))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (angle <= 2.55e+182) tmp = Float64(Float64(b_m - a) * Float64(angle * Float64(0.011111111111111112 * Float64(Float64(b_m + a) * pi)))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * b_m)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (angle <= 2.55e+182) tmp = (b_m - a) * (angle * (0.011111111111111112 * ((b_m + a) * pi))); else tmp = 0.011111111111111112 * (angle * (pi * (b_m * b_m))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[angle, 2.55e+182], N[(N[(b$95$m - a), $MachinePrecision] * N[(angle * N[(0.011111111111111112 * N[(N[(b$95$m + a), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 2.55 \cdot 10^{+182}:\\
\;\;\;\;\left(b\_m - a\right) \cdot \left(angle \cdot \left(0.011111111111111112 \cdot \left(\left(b\_m + a\right) \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot b\_m\right)\right)\right)\\
\end{array}
\end{array}
if angle < 2.55000000000000005e182Initial program 60.7%
*-commutativeN/A
pow2N/A
pow2N/A
associate-*l*N/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6471.0%
Applied egg-rr71.0%
Taylor expanded in angle around 0
Simplified68.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
+-lowering-+.f6467.0%
Simplified67.0%
if 2.55000000000000005e182 < angle Initial program 30.5%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6430.5%
Simplified30.5%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6430.0%
Simplified30.0%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6434.6%
Simplified34.6%
Final simplification63.4%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= angle 2.55e+182) (* (+ b_m a) (* (- b_m a) (* PI (* angle 0.011111111111111112)))) (* 0.011111111111111112 (* angle (* PI (* b_m b_m))))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 2.55e+182) {
tmp = (b_m + a) * ((b_m - a) * (((double) M_PI) * (angle * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * b_m)));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (angle <= 2.55e+182) {
tmp = (b_m + a) * ((b_m - a) * (Math.PI * (angle * 0.011111111111111112)));
} else {
tmp = 0.011111111111111112 * (angle * (Math.PI * (b_m * b_m)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if angle <= 2.55e+182: tmp = (b_m + a) * ((b_m - a) * (math.pi * (angle * 0.011111111111111112))) else: tmp = 0.011111111111111112 * (angle * (math.pi * (b_m * b_m))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (angle <= 2.55e+182) tmp = Float64(Float64(b_m + a) * Float64(Float64(b_m - a) * Float64(pi * Float64(angle * 0.011111111111111112)))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * b_m)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (angle <= 2.55e+182) tmp = (b_m + a) * ((b_m - a) * (pi * (angle * 0.011111111111111112))); else tmp = 0.011111111111111112 * (angle * (pi * (b_m * b_m))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[angle, 2.55e+182], N[(N[(b$95$m + a), $MachinePrecision] * N[(N[(b$95$m - a), $MachinePrecision] * N[(Pi * N[(angle * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 2.55 \cdot 10^{+182}:\\
\;\;\;\;\left(b\_m + a\right) \cdot \left(\left(b\_m - a\right) \cdot \left(\pi \cdot \left(angle \cdot 0.011111111111111112\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot b\_m\right)\right)\right)\\
\end{array}
\end{array}
if angle < 2.55000000000000005e182Initial program 60.7%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6460.7%
Simplified60.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6457.9%
Simplified57.9%
*-commutativeN/A
difference-of-squaresN/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6467.0%
Applied egg-rr67.0%
if 2.55000000000000005e182 < angle Initial program 30.5%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6430.5%
Simplified30.5%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6430.0%
Simplified30.0%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6434.6%
Simplified34.6%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= b_m 3.7e+89) (* (* 0.011111111111111112 (* PI angle)) (- (* b_m b_m) (* a a))) (* (* b_m (* angle 0.011111111111111112)) (* b_m PI))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 3.7e+89) {
tmp = (0.011111111111111112 * (((double) M_PI) * angle)) * ((b_m * b_m) - (a * a));
} else {
tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * ((double) M_PI));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 3.7e+89) {
tmp = (0.011111111111111112 * (Math.PI * angle)) * ((b_m * b_m) - (a * a));
} else {
tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * Math.PI);
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if b_m <= 3.7e+89: tmp = (0.011111111111111112 * (math.pi * angle)) * ((b_m * b_m) - (a * a)) else: tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * math.pi) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (b_m <= 3.7e+89) tmp = Float64(Float64(0.011111111111111112 * Float64(pi * angle)) * Float64(Float64(b_m * b_m) - Float64(a * a))); else tmp = Float64(Float64(b_m * Float64(angle * 0.011111111111111112)) * Float64(b_m * pi)); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (b_m <= 3.7e+89) tmp = (0.011111111111111112 * (pi * angle)) * ((b_m * b_m) - (a * a)); else tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * pi); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[b$95$m, 3.7e+89], N[(N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision] * N[(N[(b$95$m * b$95$m), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m * N[(angle * 0.011111111111111112), $MachinePrecision]), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 3.7 \cdot 10^{+89}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right) \cdot \left(b\_m \cdot b\_m - a \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m \cdot \left(angle \cdot 0.011111111111111112\right)\right) \cdot \left(b\_m \cdot \pi\right)\\
\end{array}
\end{array}
if b < 3.6999999999999998e89Initial program 59.7%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6459.7%
Simplified59.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6455.6%
Simplified55.6%
if 3.6999999999999998e89 < b Initial program 44.4%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6444.4%
Simplified44.4%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6450.2%
Simplified50.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6457.8%
Simplified57.8%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6457.8%
Applied egg-rr57.8%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6465.1%
Applied egg-rr65.1%
Final simplification57.1%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= b_m 1.06e-38) (* (* PI angle) (* (* a a) -0.011111111111111112)) (* (* b_m (* angle 0.011111111111111112)) (* b_m PI))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.06e-38) {
tmp = (((double) M_PI) * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * ((double) M_PI));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.06e-38) {
tmp = (Math.PI * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * Math.PI);
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if b_m <= 1.06e-38: tmp = (math.pi * angle) * ((a * a) * -0.011111111111111112) else: tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * math.pi) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (b_m <= 1.06e-38) tmp = Float64(Float64(pi * angle) * Float64(Float64(a * a) * -0.011111111111111112)); else tmp = Float64(Float64(b_m * Float64(angle * 0.011111111111111112)) * Float64(b_m * pi)); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (b_m <= 1.06e-38) tmp = (pi * angle) * ((a * a) * -0.011111111111111112); else tmp = (b_m * (angle * 0.011111111111111112)) * (b_m * pi); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[b$95$m, 1.06e-38], N[(N[(Pi * angle), $MachinePrecision] * N[(N[(a * a), $MachinePrecision] * -0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(N[(b$95$m * N[(angle * 0.011111111111111112), $MachinePrecision]), $MachinePrecision] * N[(b$95$m * Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 1.06 \cdot 10^{-38}:\\
\;\;\;\;\left(\pi \cdot angle\right) \cdot \left(\left(a \cdot a\right) \cdot -0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b\_m \cdot \left(angle \cdot 0.011111111111111112\right)\right) \cdot \left(b\_m \cdot \pi\right)\\
\end{array}
\end{array}
if b < 1.06000000000000001e-38Initial program 59.2%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6459.2%
Simplified59.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.0%
Simplified56.0%
Taylor expanded in b around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6444.3%
Simplified44.3%
if 1.06000000000000001e-38 < b Initial program 51.8%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6451.8%
Simplified51.8%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6451.2%
Simplified51.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6451.5%
Simplified51.5%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6451.5%
Applied egg-rr51.5%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6455.9%
Applied egg-rr55.9%
Final simplification47.2%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= b_m 1.52e-38) (* (* PI angle) (* (* a a) -0.011111111111111112)) (* b_m (* 0.011111111111111112 (* b_m (* PI angle))))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.52e-38) {
tmp = (((double) M_PI) * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = b_m * (0.011111111111111112 * (b_m * (((double) M_PI) * angle)));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.52e-38) {
tmp = (Math.PI * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = b_m * (0.011111111111111112 * (b_m * (Math.PI * angle)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if b_m <= 1.52e-38: tmp = (math.pi * angle) * ((a * a) * -0.011111111111111112) else: tmp = b_m * (0.011111111111111112 * (b_m * (math.pi * angle))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (b_m <= 1.52e-38) tmp = Float64(Float64(pi * angle) * Float64(Float64(a * a) * -0.011111111111111112)); else tmp = Float64(b_m * Float64(0.011111111111111112 * Float64(b_m * Float64(pi * angle)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (b_m <= 1.52e-38) tmp = (pi * angle) * ((a * a) * -0.011111111111111112); else tmp = b_m * (0.011111111111111112 * (b_m * (pi * angle))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[b$95$m, 1.52e-38], N[(N[(Pi * angle), $MachinePrecision] * N[(N[(a * a), $MachinePrecision] * -0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(b$95$m * N[(0.011111111111111112 * N[(b$95$m * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 1.52 \cdot 10^{-38}:\\
\;\;\;\;\left(\pi \cdot angle\right) \cdot \left(\left(a \cdot a\right) \cdot -0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;b\_m \cdot \left(0.011111111111111112 \cdot \left(b\_m \cdot \left(\pi \cdot angle\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.5200000000000001e-38Initial program 59.2%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6459.2%
Simplified59.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.0%
Simplified56.0%
Taylor expanded in b around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6444.3%
Simplified44.3%
if 1.5200000000000001e-38 < b Initial program 51.8%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6451.8%
Simplified51.8%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6451.2%
Simplified51.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6451.5%
Simplified51.5%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6451.5%
Applied egg-rr51.5%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6455.9%
Applied egg-rr55.9%
Final simplification47.2%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= b_m 1.85e-38) (* (* PI angle) (* (* a a) -0.011111111111111112)) (* 0.011111111111111112 (* b_m (* b_m (* PI angle))))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.85e-38) {
tmp = (((double) M_PI) * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = 0.011111111111111112 * (b_m * (b_m * (((double) M_PI) * angle)));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 1.85e-38) {
tmp = (Math.PI * angle) * ((a * a) * -0.011111111111111112);
} else {
tmp = 0.011111111111111112 * (b_m * (b_m * (Math.PI * angle)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if b_m <= 1.85e-38: tmp = (math.pi * angle) * ((a * a) * -0.011111111111111112) else: tmp = 0.011111111111111112 * (b_m * (b_m * (math.pi * angle))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (b_m <= 1.85e-38) tmp = Float64(Float64(pi * angle) * Float64(Float64(a * a) * -0.011111111111111112)); else tmp = Float64(0.011111111111111112 * Float64(b_m * Float64(b_m * Float64(pi * angle)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (b_m <= 1.85e-38) tmp = (pi * angle) * ((a * a) * -0.011111111111111112); else tmp = 0.011111111111111112 * (b_m * (b_m * (pi * angle))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[b$95$m, 1.85e-38], N[(N[(Pi * angle), $MachinePrecision] * N[(N[(a * a), $MachinePrecision] * -0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(b$95$m * N[(b$95$m * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 1.85 \cdot 10^{-38}:\\
\;\;\;\;\left(\pi \cdot angle\right) \cdot \left(\left(a \cdot a\right) \cdot -0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(b\_m \cdot \left(\pi \cdot angle\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.85e-38Initial program 59.2%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6459.2%
Simplified59.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.0%
Simplified56.0%
Taylor expanded in b around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6444.3%
Simplified44.3%
if 1.85e-38 < b Initial program 51.8%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6451.8%
Simplified51.8%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6451.2%
Simplified51.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6451.5%
Simplified51.5%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f6455.9%
Applied egg-rr55.9%
Final simplification47.2%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (if (<= b_m 5e+17) (* 0.011111111111111112 (* (* PI angle) (* b_m b_m))) (* 0.011111111111111112 (* b_m (* b_m (* PI angle))))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 5e+17) {
tmp = 0.011111111111111112 * ((((double) M_PI) * angle) * (b_m * b_m));
} else {
tmp = 0.011111111111111112 * (b_m * (b_m * (((double) M_PI) * angle)));
}
return tmp;
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
double tmp;
if (b_m <= 5e+17) {
tmp = 0.011111111111111112 * ((Math.PI * angle) * (b_m * b_m));
} else {
tmp = 0.011111111111111112 * (b_m * (b_m * (Math.PI * angle)));
}
return tmp;
}
b_m = math.fabs(b) def code(a, b_m, angle): tmp = 0 if b_m <= 5e+17: tmp = 0.011111111111111112 * ((math.pi * angle) * (b_m * b_m)) else: tmp = 0.011111111111111112 * (b_m * (b_m * (math.pi * angle))) return tmp
b_m = abs(b) function code(a, b_m, angle) tmp = 0.0 if (b_m <= 5e+17) tmp = Float64(0.011111111111111112 * Float64(Float64(pi * angle) * Float64(b_m * b_m))); else tmp = Float64(0.011111111111111112 * Float64(b_m * Float64(b_m * Float64(pi * angle)))); end return tmp end
b_m = abs(b); function tmp_2 = code(a, b_m, angle) tmp = 0.0; if (b_m <= 5e+17) tmp = 0.011111111111111112 * ((pi * angle) * (b_m * b_m)); else tmp = 0.011111111111111112 * (b_m * (b_m * (pi * angle))); end tmp_2 = tmp; end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := If[LessEqual[b$95$m, 5e+17], N[(0.011111111111111112 * N[(N[(Pi * angle), $MachinePrecision] * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(b$95$m * N[(b$95$m * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
b_m = \left|b\right|
\\
\begin{array}{l}
\mathbf{if}\;b\_m \leq 5 \cdot 10^{+17}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\pi \cdot angle\right) \cdot \left(b\_m \cdot b\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(b\_m \cdot \left(b\_m \cdot \left(\pi \cdot angle\right)\right)\right)\\
\end{array}
\end{array}
if b < 5e17Initial program 60.0%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6460.0%
Simplified60.0%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.3%
Simplified56.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6438.7%
Simplified38.7%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6438.7%
Applied egg-rr38.7%
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f6438.7%
Applied egg-rr38.7%
if 5e17 < b Initial program 48.1%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6448.1%
Simplified48.1%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6449.4%
Simplified49.4%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6451.6%
Simplified51.6%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f6456.6%
Applied egg-rr56.6%
Final simplification42.6%
b_m = (fabs.f64 b) (FPCore (a b_m angle) :precision binary64 (* 0.011111111111111112 (* angle (* PI (* b_m b_m)))))
b_m = fabs(b);
double code(double a, double b_m, double angle) {
return 0.011111111111111112 * (angle * (((double) M_PI) * (b_m * b_m)));
}
b_m = Math.abs(b);
public static double code(double a, double b_m, double angle) {
return 0.011111111111111112 * (angle * (Math.PI * (b_m * b_m)));
}
b_m = math.fabs(b) def code(a, b_m, angle): return 0.011111111111111112 * (angle * (math.pi * (b_m * b_m)))
b_m = abs(b) function code(a, b_m, angle) return Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b_m * b_m)))) end
b_m = abs(b); function tmp = code(a, b_m, angle) tmp = 0.011111111111111112 * (angle * (pi * (b_m * b_m))); end
b_m = N[Abs[b], $MachinePrecision] code[a_, b$95$m_, angle_] := N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b$95$m * b$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
b_m = \left|b\right|
\\
0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b\_m \cdot b\_m\right)\right)\right)
\end{array}
Initial program 57.4%
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6457.4%
Simplified57.4%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6454.8%
Simplified54.8%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6441.5%
Simplified41.5%
herbie shell --seed 2024192
(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)))))