
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* (/ angle 180.0) PI))) (+ (pow (* a (sin t_0)) 2.0) (pow (* b (cos t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * ((double) M_PI);
return pow((a * sin(t_0)), 2.0) + pow((b * cos(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * Math.PI;
return Math.pow((a * Math.sin(t_0)), 2.0) + Math.pow((b * Math.cos(t_0)), 2.0);
}
def code(a, b, angle): t_0 = (angle / 180.0) * math.pi return math.pow((a * math.sin(t_0)), 2.0) + math.pow((b * math.cos(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(Float64(angle / 180.0) * pi) return Float64((Float64(a * sin(t_0)) ^ 2.0) + (Float64(b * cos(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = (angle / 180.0) * pi; tmp = ((a * sin(t_0)) ^ 2.0) + ((b * cos(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, N[(N[Power[N[(a * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
{\left(a \cdot \sin t\_0\right)}^{2} + {\left(b \cdot \cos t\_0\right)}^{2}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* (/ angle 180.0) PI))) (+ (pow (* a (sin t_0)) 2.0) (pow (* b (cos t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * ((double) M_PI);
return pow((a * sin(t_0)), 2.0) + pow((b * cos(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * Math.PI;
return Math.pow((a * Math.sin(t_0)), 2.0) + Math.pow((b * Math.cos(t_0)), 2.0);
}
def code(a, b, angle): t_0 = (angle / 180.0) * math.pi return math.pow((a * math.sin(t_0)), 2.0) + math.pow((b * math.cos(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(Float64(angle / 180.0) * pi) return Float64((Float64(a * sin(t_0)) ^ 2.0) + (Float64(b * cos(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = (angle / 180.0) * pi; tmp = ((a * sin(t_0)) ^ 2.0) + ((b * cos(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, N[(N[Power[N[(a * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
{\left(a \cdot \sin t\_0\right)}^{2} + {\left(b \cdot \cos t\_0\right)}^{2}
\end{array}
\end{array}
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* a (* angle_m (* PI -0.005555555555555556)))))
(if (<= angle_m 0.94)
(+
(*
(* b b)
(+ (* (* (* angle_m angle_m) -3.08641975308642e-5) (* PI PI)) 1.0))
(* t_0 t_0))
(+
(* b b)
(*
(* a a)
(+
0.5
(*
(cos (* (- (* angle_m (+ PI 1.0)) angle_m) 0.011111111111111112))
-0.5)))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (((double) M_PI) * -0.005555555555555556));
double tmp;
if (angle_m <= 0.94) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (((double) M_PI) * ((double) M_PI))) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((a * a) * (0.5 + (cos((((angle_m * (((double) M_PI) + 1.0)) - angle_m) * 0.011111111111111112)) * -0.5)));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (Math.PI * -0.005555555555555556));
double tmp;
if (angle_m <= 0.94) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (Math.PI * Math.PI)) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((a * a) * (0.5 + (Math.cos((((angle_m * (Math.PI + 1.0)) - angle_m) * 0.011111111111111112)) * -0.5)));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = a * (angle_m * (math.pi * -0.005555555555555556)) tmp = 0 if angle_m <= 0.94: tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (math.pi * math.pi)) + 1.0)) + (t_0 * t_0) else: tmp = (b * b) + ((a * a) * (0.5 + (math.cos((((angle_m * (math.pi + 1.0)) - angle_m) * 0.011111111111111112)) * -0.5))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(a * Float64(angle_m * Float64(pi * -0.005555555555555556))) tmp = 0.0 if (angle_m <= 0.94) tmp = Float64(Float64(Float64(b * b) * Float64(Float64(Float64(Float64(angle_m * angle_m) * -3.08641975308642e-5) * Float64(pi * pi)) + 1.0)) + Float64(t_0 * t_0)); else tmp = Float64(Float64(b * b) + Float64(Float64(a * a) * Float64(0.5 + Float64(cos(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) - angle_m) * 0.011111111111111112)) * -0.5)))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = a * (angle_m * (pi * -0.005555555555555556)); tmp = 0.0; if (angle_m <= 0.94) tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (pi * pi)) + 1.0)) + (t_0 * t_0); else tmp = (b * b) + ((a * a) * (0.5 + (cos((((angle_m * (pi + 1.0)) - angle_m) * 0.011111111111111112)) * -0.5))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(a * N[(angle$95$m * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle$95$m, 0.94], N[(N[(N[(b * b), $MachinePrecision] * N[(N[(N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * -3.08641975308642e-5), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] * N[(0.5 + N[(N[Cos[N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] - angle$95$m), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := a \cdot \left(angle\_m \cdot \left(\pi \cdot -0.005555555555555556\right)\right)\\
\mathbf{if}\;angle\_m \leq 0.94:\\
\;\;\;\;\left(b \cdot b\right) \cdot \left(\left(\left(angle\_m \cdot angle\_m\right) \cdot -3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\pi \cdot \pi\right) + 1\right) + t\_0 \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + \left(a \cdot a\right) \cdot \left(0.5 + \cos \left(\left(angle\_m \cdot \left(\pi + 1\right) - angle\_m\right) \cdot 0.011111111111111112\right) \cdot -0.5\right)\\
\end{array}
\end{array}
if angle < 0.93999999999999995Initial program 86.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified87.0%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-commutativeN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.9%
Applied egg-rr86.9%
Taylor expanded in angle around 0
Simplified71.0%
if 0.93999999999999995 < angle Initial program 60.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified60.9%
Taylor expanded in angle around 0
Simplified60.1%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
clear-numN/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f6460.1%
Applied egg-rr60.1%
Applied egg-rr5.7%
Applied egg-rr60.2%
Final simplification68.8%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* a (sin (/ (* angle_m PI) 180.0))) 2.0) (pow (* b (cos (* (* angle_m (pow PI 0.6666666666666666)) (/ (cbrt PI) 180.0)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((a * sin(((angle_m * ((double) M_PI)) / 180.0))), 2.0) + pow((b * cos(((angle_m * pow(((double) M_PI), 0.6666666666666666)) * (cbrt(((double) M_PI)) / 180.0)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((a * Math.sin(((angle_m * Math.PI) / 180.0))), 2.0) + Math.pow((b * Math.cos(((angle_m * Math.pow(Math.PI, 0.6666666666666666)) * (Math.cbrt(Math.PI) / 180.0)))), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(a * sin(Float64(Float64(angle_m * pi) / 180.0))) ^ 2.0) + (Float64(b * cos(Float64(Float64(angle_m * (pi ^ 0.6666666666666666)) * Float64(cbrt(pi) / 180.0)))) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(a * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Cos[N[(N[(angle$95$m * N[Power[Pi, 0.6666666666666666], $MachinePrecision]), $MachinePrecision] * N[(N[Power[Pi, 1/3], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(a \cdot \sin \left(\frac{angle\_m \cdot \pi}{180}\right)\right)}^{2} + {\left(b \cdot \cos \left(\left(angle\_m \cdot {\pi}^{0.6666666666666666}\right) \cdot \frac{\sqrt[3]{\pi}}{180}\right)\right)}^{2}
\end{array}
Initial program 81.5%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified81.6%
add-cube-cbrtN/A
associate-*r*N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
pow2N/A
pow1/3N/A
pow-powN/A
pow-lowering-pow.f64N/A
PI-lowering-PI.f64N/A
metadata-evalN/A
/-lowering-/.f64N/A
cbrt-lowering-cbrt.f64N/A
PI-lowering-PI.f6481.7%
Applied egg-rr81.7%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* a (sin (/ (* angle_m PI) 180.0))) 2.0) (* b b)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((a * sin(((angle_m * ((double) M_PI)) / 180.0))), 2.0) + (b * b);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((a * Math.sin(((angle_m * Math.PI) / 180.0))), 2.0) + (b * b);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((a * math.sin(((angle_m * math.pi) / 180.0))), 2.0) + (b * b)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(a * sin(Float64(Float64(angle_m * pi) / 180.0))) ^ 2.0) + Float64(b * b)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((a * sin(((angle_m * pi) / 180.0))) ^ 2.0) + (b * b); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(a * N[Sin[N[(N[(angle$95$m * Pi), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(b * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(a \cdot \sin \left(\frac{angle\_m \cdot \pi}{180}\right)\right)}^{2} + b \cdot b
\end{array}
Initial program 81.5%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified81.6%
Taylor expanded in angle around 0
Simplified81.6%
*-rgt-identityN/A
pow2N/A
*-lowering-*.f6481.6%
Applied egg-rr81.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (* b b) (pow (* a (sin (* PI (/ angle_m 180.0)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return (b * b) + pow((a * sin((((double) M_PI) * (angle_m / 180.0)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return (b * b) + Math.pow((a * Math.sin((Math.PI * (angle_m / 180.0)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return (b * b) + math.pow((a * math.sin((math.pi * (angle_m / 180.0)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64(Float64(b * b) + (Float64(a * sin(Float64(pi * Float64(angle_m / 180.0)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (b * b) + ((a * sin((pi * (angle_m / 180.0)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[(b * b), $MachinePrecision] + N[Power[N[(a * N[Sin[N[(Pi * N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
b \cdot b + {\left(a \cdot \sin \left(\pi \cdot \frac{angle\_m}{180}\right)\right)}^{2}
\end{array}
Initial program 81.5%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified81.6%
Taylor expanded in angle around 0
Simplified81.6%
*-rgt-identityN/A
pow2N/A
*-lowering-*.f6481.6%
Applied egg-rr81.6%
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f6481.6%
Applied egg-rr81.6%
Final simplification81.6%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* a (* angle_m (* PI -0.005555555555555556)))))
(if (<= angle_m 0.16)
(+
(*
(* b b)
(+ (* (* (* angle_m angle_m) -3.08641975308642e-5) (* PI PI)) 1.0))
(* t_0 t_0))
(+
(* b b)
(*
(* a a)
(+
0.5
(*
-0.5
(cos (* 0.011111111111111112 (* angle_m (+ (+ PI 1.0) -1.0)))))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (((double) M_PI) * -0.005555555555555556));
double tmp;
if (angle_m <= 0.16) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (((double) M_PI) * ((double) M_PI))) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((a * a) * (0.5 + (-0.5 * cos((0.011111111111111112 * (angle_m * ((((double) M_PI) + 1.0) + -1.0)))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (Math.PI * -0.005555555555555556));
double tmp;
if (angle_m <= 0.16) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (Math.PI * Math.PI)) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((a * a) * (0.5 + (-0.5 * Math.cos((0.011111111111111112 * (angle_m * ((Math.PI + 1.0) + -1.0)))))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = a * (angle_m * (math.pi * -0.005555555555555556)) tmp = 0 if angle_m <= 0.16: tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (math.pi * math.pi)) + 1.0)) + (t_0 * t_0) else: tmp = (b * b) + ((a * a) * (0.5 + (-0.5 * math.cos((0.011111111111111112 * (angle_m * ((math.pi + 1.0) + -1.0))))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(a * Float64(angle_m * Float64(pi * -0.005555555555555556))) tmp = 0.0 if (angle_m <= 0.16) tmp = Float64(Float64(Float64(b * b) * Float64(Float64(Float64(Float64(angle_m * angle_m) * -3.08641975308642e-5) * Float64(pi * pi)) + 1.0)) + Float64(t_0 * t_0)); else tmp = Float64(Float64(b * b) + Float64(Float64(a * a) * Float64(0.5 + Float64(-0.5 * cos(Float64(0.011111111111111112 * Float64(angle_m * Float64(Float64(pi + 1.0) + -1.0)))))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = a * (angle_m * (pi * -0.005555555555555556)); tmp = 0.0; if (angle_m <= 0.16) tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (pi * pi)) + 1.0)) + (t_0 * t_0); else tmp = (b * b) + ((a * a) * (0.5 + (-0.5 * cos((0.011111111111111112 * (angle_m * ((pi + 1.0) + -1.0))))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(a * N[(angle$95$m * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle$95$m, 0.16], N[(N[(N[(b * b), $MachinePrecision] * N[(N[(N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * -3.08641975308642e-5), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] * N[(0.5 + N[(-0.5 * N[Cos[N[(0.011111111111111112 * N[(angle$95$m * N[(N[(Pi + 1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := a \cdot \left(angle\_m \cdot \left(\pi \cdot -0.005555555555555556\right)\right)\\
\mathbf{if}\;angle\_m \leq 0.16:\\
\;\;\;\;\left(b \cdot b\right) \cdot \left(\left(\left(angle\_m \cdot angle\_m\right) \cdot -3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\pi \cdot \pi\right) + 1\right) + t\_0 \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + \left(a \cdot a\right) \cdot \left(0.5 + -0.5 \cdot \cos \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\left(\pi + 1\right) + -1\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 0.160000000000000003Initial program 86.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified87.0%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-commutativeN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.9%
Applied egg-rr86.9%
Taylor expanded in angle around 0
Simplified71.0%
if 0.160000000000000003 < angle Initial program 60.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified60.9%
Taylor expanded in angle around 0
Simplified60.1%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
clear-numN/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f6460.1%
Applied egg-rr60.1%
Applied egg-rr5.7%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
Simplified60.2%
Final simplification68.8%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* a (* angle_m (* PI -0.005555555555555556)))))
(if (<= angle_m 0.205)
(+
(*
(* b b)
(+ (* (* (* angle_m angle_m) -3.08641975308642e-5) (* PI PI)) 1.0))
(* t_0 t_0))
(+
(* b b)
(* a (* a (- 0.5 (* 0.5 (cos (* 2.0 (/ PI (/ 180.0 angle_m))))))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (((double) M_PI) * -0.005555555555555556));
double tmp;
if (angle_m <= 0.205) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (((double) M_PI) * ((double) M_PI))) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + (a * (a * (0.5 - (0.5 * cos((2.0 * (((double) M_PI) / (180.0 / angle_m))))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (Math.PI * -0.005555555555555556));
double tmp;
if (angle_m <= 0.205) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (Math.PI * Math.PI)) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + (a * (a * (0.5 - (0.5 * Math.cos((2.0 * (Math.PI / (180.0 / angle_m))))))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = a * (angle_m * (math.pi * -0.005555555555555556)) tmp = 0 if angle_m <= 0.205: tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (math.pi * math.pi)) + 1.0)) + (t_0 * t_0) else: tmp = (b * b) + (a * (a * (0.5 - (0.5 * math.cos((2.0 * (math.pi / (180.0 / angle_m)))))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(a * Float64(angle_m * Float64(pi * -0.005555555555555556))) tmp = 0.0 if (angle_m <= 0.205) tmp = Float64(Float64(Float64(b * b) * Float64(Float64(Float64(Float64(angle_m * angle_m) * -3.08641975308642e-5) * Float64(pi * pi)) + 1.0)) + Float64(t_0 * t_0)); else tmp = Float64(Float64(b * b) + Float64(a * Float64(a * Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * Float64(pi / Float64(180.0 / angle_m))))))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = a * (angle_m * (pi * -0.005555555555555556)); tmp = 0.0; if (angle_m <= 0.205) tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (pi * pi)) + 1.0)) + (t_0 * t_0); else tmp = (b * b) + (a * (a * (0.5 - (0.5 * cos((2.0 * (pi / (180.0 / angle_m)))))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(a * N[(angle$95$m * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle$95$m, 0.205], N[(N[(N[(b * b), $MachinePrecision] * N[(N[(N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * -3.08641975308642e-5), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(a * N[(a * N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := a \cdot \left(angle\_m \cdot \left(\pi \cdot -0.005555555555555556\right)\right)\\
\mathbf{if}\;angle\_m \leq 0.205:\\
\;\;\;\;\left(b \cdot b\right) \cdot \left(\left(\left(angle\_m \cdot angle\_m\right) \cdot -3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\pi \cdot \pi\right) + 1\right) + t\_0 \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + a \cdot \left(a \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \frac{\pi}{\frac{180}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if angle < 0.204999999999999988Initial program 86.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified87.0%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-commutativeN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.9%
Applied egg-rr86.9%
Taylor expanded in angle around 0
Simplified71.0%
if 0.204999999999999988 < angle Initial program 60.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified60.9%
Taylor expanded in angle around 0
Simplified60.1%
*-rgt-identityN/A
pow2N/A
*-lowering-*.f6460.1%
Applied egg-rr60.1%
+-commutativeN/A
pow2N/A
*-rgt-identityN/A
+-lowering-+.f64N/A
*-rgt-identityN/A
pow2N/A
*-lowering-*.f64N/A
unpow-prod-downN/A
pow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
sqr-sin-aN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
clear-numN/A
associate-/r*N/A
Applied egg-rr59.9%
Final simplification68.7%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* a (* angle_m (* PI -0.005555555555555556)))))
(if (<= angle_m 53.0)
(+
(*
(* b b)
(+ (* (* (* angle_m angle_m) -3.08641975308642e-5) (* PI PI)) 1.0))
(* t_0 t_0))
(+
(* b b)
(* (* angle_m 3.08641975308642e-5) (* angle_m (* a (* PI (* a PI)))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (((double) M_PI) * -0.005555555555555556));
double tmp;
if (angle_m <= 53.0) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (((double) M_PI) * ((double) M_PI))) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (((double) M_PI) * (a * ((double) M_PI))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * (Math.PI * -0.005555555555555556));
double tmp;
if (angle_m <= 53.0) {
tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (Math.PI * Math.PI)) + 1.0)) + (t_0 * t_0);
} else {
tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (Math.PI * (a * Math.PI)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = a * (angle_m * (math.pi * -0.005555555555555556)) tmp = 0 if angle_m <= 53.0: tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (math.pi * math.pi)) + 1.0)) + (t_0 * t_0) else: tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (math.pi * (a * math.pi))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(a * Float64(angle_m * Float64(pi * -0.005555555555555556))) tmp = 0.0 if (angle_m <= 53.0) tmp = Float64(Float64(Float64(b * b) * Float64(Float64(Float64(Float64(angle_m * angle_m) * -3.08641975308642e-5) * Float64(pi * pi)) + 1.0)) + Float64(t_0 * t_0)); else tmp = Float64(Float64(b * b) + Float64(Float64(angle_m * 3.08641975308642e-5) * Float64(angle_m * Float64(a * Float64(pi * Float64(a * pi)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = a * (angle_m * (pi * -0.005555555555555556)); tmp = 0.0; if (angle_m <= 53.0) tmp = ((b * b) * ((((angle_m * angle_m) * -3.08641975308642e-5) * (pi * pi)) + 1.0)) + (t_0 * t_0); else tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (pi * (a * pi))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(a * N[(angle$95$m * N[(Pi * -0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle$95$m, 53.0], N[(N[(N[(b * b), $MachinePrecision] * N[(N[(N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * -3.08641975308642e-5), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision] * N[(angle$95$m * N[(a * N[(Pi * N[(a * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := a \cdot \left(angle\_m \cdot \left(\pi \cdot -0.005555555555555556\right)\right)\\
\mathbf{if}\;angle\_m \leq 53:\\
\;\;\;\;\left(b \cdot b\right) \cdot \left(\left(\left(angle\_m \cdot angle\_m\right) \cdot -3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\pi \cdot \pi\right) + 1\right) + t\_0 \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + \left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(angle\_m \cdot \left(a \cdot \left(\pi \cdot \left(a \cdot \pi\right)\right)\right)\right)\\
\end{array}
\end{array}
if angle < 53Initial program 86.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified87.0%
clear-numN/A
associate-/r*N/A
clear-numN/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-commutativeN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.9%
Applied egg-rr86.9%
Taylor expanded in angle around 0
Simplified71.0%
if 53 < angle Initial program 60.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified60.9%
Taylor expanded in angle around 0
Simplified60.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified52.1%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6456.0%
Applied egg-rr56.0%
Final simplification67.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* a (* angle_m PI))))
(if (<= a 1.02e-82)
(* b b)
(+ (* b b) (* 3.08641975308642e-5 (* t_0 t_0))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * ((double) M_PI));
double tmp;
if (a <= 1.02e-82) {
tmp = b * b;
} else {
tmp = (b * b) + (3.08641975308642e-5 * (t_0 * t_0));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = a * (angle_m * Math.PI);
double tmp;
if (a <= 1.02e-82) {
tmp = b * b;
} else {
tmp = (b * b) + (3.08641975308642e-5 * (t_0 * t_0));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = a * (angle_m * math.pi) tmp = 0 if a <= 1.02e-82: tmp = b * b else: tmp = (b * b) + (3.08641975308642e-5 * (t_0 * t_0)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(a * Float64(angle_m * pi)) tmp = 0.0 if (a <= 1.02e-82) tmp = Float64(b * b); else tmp = Float64(Float64(b * b) + Float64(3.08641975308642e-5 * Float64(t_0 * t_0))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = a * (angle_m * pi); tmp = 0.0; if (a <= 1.02e-82) tmp = b * b; else tmp = (b * b) + (3.08641975308642e-5 * (t_0 * t_0)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(a * N[(angle$95$m * Pi), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, 1.02e-82], N[(b * b), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(3.08641975308642e-5 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := a \cdot \left(angle\_m \cdot \pi\right)\\
\mathbf{if}\;a \leq 1.02 \cdot 10^{-82}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + 3.08641975308642 \cdot 10^{-5} \cdot \left(t\_0 \cdot t\_0\right)\\
\end{array}
\end{array}
if a < 1.02000000000000007e-82Initial program 79.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6460.5%
Simplified60.5%
if 1.02000000000000007e-82 < a Initial program 86.4%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified86.5%
Taylor expanded in angle around 0
Simplified86.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified69.5%
Taylor expanded in b around inf
distribute-rgt-inN/A
*-lft-identityN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*l/N/A
associate-/l*N/A
*-inversesN/A
*-lowering-*.f64N/A
Simplified83.0%
Final simplification66.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= a 4.2e+153)
(+
(* b b)
(* angle_m (* (* angle_m 3.08641975308642e-5) (* a (* PI (* a PI))))))
(+
(* b b)
(* a (* (* a PI) (* PI (* angle_m (* angle_m 3.08641975308642e-5))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 4.2e+153) {
tmp = (b * b) + (angle_m * ((angle_m * 3.08641975308642e-5) * (a * (((double) M_PI) * (a * ((double) M_PI))))));
} else {
tmp = (b * b) + (a * ((a * ((double) M_PI)) * (((double) M_PI) * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (a <= 4.2e+153) {
tmp = (b * b) + (angle_m * ((angle_m * 3.08641975308642e-5) * (a * (Math.PI * (a * Math.PI)))));
} else {
tmp = (b * b) + (a * ((a * Math.PI) * (Math.PI * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 4.2e+153: tmp = (b * b) + (angle_m * ((angle_m * 3.08641975308642e-5) * (a * (math.pi * (a * math.pi))))) else: tmp = (b * b) + (a * ((a * math.pi) * (math.pi * (angle_m * (angle_m * 3.08641975308642e-5))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 4.2e+153) tmp = Float64(Float64(b * b) + Float64(angle_m * Float64(Float64(angle_m * 3.08641975308642e-5) * Float64(a * Float64(pi * Float64(a * pi)))))); else tmp = Float64(Float64(b * b) + Float64(a * Float64(Float64(a * pi) * Float64(pi * Float64(angle_m * Float64(angle_m * 3.08641975308642e-5)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 4.2e+153) tmp = (b * b) + (angle_m * ((angle_m * 3.08641975308642e-5) * (a * (pi * (a * pi))))); else tmp = (b * b) + (a * ((a * pi) * (pi * (angle_m * (angle_m * 3.08641975308642e-5))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 4.2e+153], N[(N[(b * b), $MachinePrecision] + N[(angle$95$m * N[(N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision] * N[(a * N[(Pi * N[(a * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(a * N[(N[(a * Pi), $MachinePrecision] * N[(Pi * N[(angle$95$m * N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 4.2 \cdot 10^{+153}:\\
\;\;\;\;b \cdot b + angle\_m \cdot \left(\left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(a \cdot \left(\pi \cdot \left(a \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + a \cdot \left(\left(a \cdot \pi\right) \cdot \left(\pi \cdot \left(angle\_m \cdot \left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\right)\\
\end{array}
\end{array}
if a < 4.20000000000000033e153Initial program 79.2%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified79.4%
Taylor expanded in angle around 0
Simplified79.4%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified65.1%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6471.3%
Applied egg-rr71.3%
if 4.20000000000000033e153 < a Initial program 99.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.7%
Taylor expanded in angle around 0
Simplified99.7%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified68.9%
associate-*l*N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6489.6%
Applied egg-rr89.6%
Final simplification73.3%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= a 1.95e+151)
(+
(* b b)
(* (* angle_m 3.08641975308642e-5) (* angle_m (* a (* PI (* a PI))))))
(+
(* b b)
(* a (* (* a PI) (* PI (* angle_m (* angle_m 3.08641975308642e-5))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.95e+151) {
tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (((double) M_PI) * (a * ((double) M_PI))))));
} else {
tmp = (b * b) + (a * ((a * ((double) M_PI)) * (((double) M_PI) * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.95e+151) {
tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (Math.PI * (a * Math.PI)))));
} else {
tmp = (b * b) + (a * ((a * Math.PI) * (Math.PI * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 1.95e+151: tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (math.pi * (a * math.pi))))) else: tmp = (b * b) + (a * ((a * math.pi) * (math.pi * (angle_m * (angle_m * 3.08641975308642e-5))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 1.95e+151) tmp = Float64(Float64(b * b) + Float64(Float64(angle_m * 3.08641975308642e-5) * Float64(angle_m * Float64(a * Float64(pi * Float64(a * pi)))))); else tmp = Float64(Float64(b * b) + Float64(a * Float64(Float64(a * pi) * Float64(pi * Float64(angle_m * Float64(angle_m * 3.08641975308642e-5)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 1.95e+151) tmp = (b * b) + ((angle_m * 3.08641975308642e-5) * (angle_m * (a * (pi * (a * pi))))); else tmp = (b * b) + (a * ((a * pi) * (pi * (angle_m * (angle_m * 3.08641975308642e-5))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 1.95e+151], N[(N[(b * b), $MachinePrecision] + N[(N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision] * N[(angle$95$m * N[(a * N[(Pi * N[(a * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(a * N[(N[(a * Pi), $MachinePrecision] * N[(Pi * N[(angle$95$m * N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.95 \cdot 10^{+151}:\\
\;\;\;\;b \cdot b + \left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(angle\_m \cdot \left(a \cdot \left(\pi \cdot \left(a \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + a \cdot \left(\left(a \cdot \pi\right) \cdot \left(\pi \cdot \left(angle\_m \cdot \left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\right)\\
\end{array}
\end{array}
if a < 1.94999999999999988e151Initial program 79.2%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified79.4%
Taylor expanded in angle around 0
Simplified79.4%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified65.1%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6471.3%
Applied egg-rr71.3%
if 1.94999999999999988e151 < a Initial program 99.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.7%
Taylor expanded in angle around 0
Simplified99.7%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified68.9%
associate-*l*N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6489.6%
Applied egg-rr89.6%
Final simplification73.3%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 1.75e-169)
(* angle_m (* (* a a) (* angle_m (* (* PI PI) 3.08641975308642e-5))))
(+
(* b b)
(* a (* (* a PI) (* PI (* angle_m (* angle_m 3.08641975308642e-5))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e-169) {
tmp = angle_m * ((a * a) * (angle_m * ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5)));
} else {
tmp = (b * b) + (a * ((a * ((double) M_PI)) * (((double) M_PI) * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e-169) {
tmp = angle_m * ((a * a) * (angle_m * ((Math.PI * Math.PI) * 3.08641975308642e-5)));
} else {
tmp = (b * b) + (a * ((a * Math.PI) * (Math.PI * (angle_m * (angle_m * 3.08641975308642e-5)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.75e-169: tmp = angle_m * ((a * a) * (angle_m * ((math.pi * math.pi) * 3.08641975308642e-5))) else: tmp = (b * b) + (a * ((a * math.pi) * (math.pi * (angle_m * (angle_m * 3.08641975308642e-5))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.75e-169) tmp = Float64(angle_m * Float64(Float64(a * a) * Float64(angle_m * Float64(Float64(pi * pi) * 3.08641975308642e-5)))); else tmp = Float64(Float64(b * b) + Float64(a * Float64(Float64(a * pi) * Float64(pi * Float64(angle_m * Float64(angle_m * 3.08641975308642e-5)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 1.75e-169) tmp = angle_m * ((a * a) * (angle_m * ((pi * pi) * 3.08641975308642e-5))); else tmp = (b * b) + (a * ((a * pi) * (pi * (angle_m * (angle_m * 3.08641975308642e-5))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.75e-169], N[(angle$95$m * N[(N[(a * a), $MachinePrecision] * N[(angle$95$m * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(a * N[(N[(a * Pi), $MachinePrecision] * N[(Pi * N[(angle$95$m * N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.75 \cdot 10^{-169}:\\
\;\;\;\;angle\_m \cdot \left(\left(a \cdot a\right) \cdot \left(angle\_m \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + a \cdot \left(\left(a \cdot \pi\right) \cdot \left(\pi \cdot \left(angle\_m \cdot \left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.7500000000000001e-169Initial program 87.3%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified87.5%
Taylor expanded in angle around 0
Simplified88.0%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified68.0%
Taylor expanded in b around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6442.7%
Simplified42.7%
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f6447.4%
Applied egg-rr47.4%
if 1.7500000000000001e-169 < b Initial program 71.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified72.0%
Taylor expanded in angle around 0
Simplified71.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified61.4%
associate-*l*N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6466.3%
Applied egg-rr66.3%
Final simplification54.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= a 9.2e+86) (* b b) (* a (* (* angle_m (* (* PI PI) 3.08641975308642e-5)) (* a angle_m)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 9.2e+86) {
tmp = b * b;
} else {
tmp = a * ((angle_m * ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5)) * (a * angle_m));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (a <= 9.2e+86) {
tmp = b * b;
} else {
tmp = a * ((angle_m * ((Math.PI * Math.PI) * 3.08641975308642e-5)) * (a * angle_m));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 9.2e+86: tmp = b * b else: tmp = a * ((angle_m * ((math.pi * math.pi) * 3.08641975308642e-5)) * (a * angle_m)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 9.2e+86) tmp = Float64(b * b); else tmp = Float64(a * Float64(Float64(angle_m * Float64(Float64(pi * pi) * 3.08641975308642e-5)) * Float64(a * angle_m))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 9.2e+86) tmp = b * b; else tmp = a * ((angle_m * ((pi * pi) * 3.08641975308642e-5)) * (a * angle_m)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 9.2e+86], N[(b * b), $MachinePrecision], N[(a * N[(N[(angle$95$m * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision] * N[(a * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 9.2 \cdot 10^{+86}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(\left(angle\_m \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right) \cdot \left(a \cdot angle\_m\right)\right)\\
\end{array}
\end{array}
if a < 9.19999999999999958e86Initial program 79.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6461.3%
Simplified61.3%
if 9.19999999999999958e86 < a Initial program 90.2%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified90.2%
Taylor expanded in angle around 0
Simplified90.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified64.3%
Taylor expanded in b around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6455.5%
Simplified55.5%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6469.1%
Applied egg-rr69.1%
Final simplification62.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 1.65e-147) (* angle_m (* (* a a) (* angle_m (* (* PI PI) 3.08641975308642e-5)))) (* b b)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.65e-147) {
tmp = angle_m * ((a * a) * (angle_m * ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5)));
} else {
tmp = b * b;
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.65e-147) {
tmp = angle_m * ((a * a) * (angle_m * ((Math.PI * Math.PI) * 3.08641975308642e-5)));
} else {
tmp = b * b;
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.65e-147: tmp = angle_m * ((a * a) * (angle_m * ((math.pi * math.pi) * 3.08641975308642e-5))) else: tmp = b * b return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.65e-147) tmp = Float64(angle_m * Float64(Float64(a * a) * Float64(angle_m * Float64(Float64(pi * pi) * 3.08641975308642e-5)))); else tmp = Float64(b * b); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 1.65e-147) tmp = angle_m * ((a * a) * (angle_m * ((pi * pi) * 3.08641975308642e-5))); else tmp = b * b; end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.65e-147], N[(angle$95$m * N[(N[(a * a), $MachinePrecision] * N[(angle$95$m * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * b), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.65 \cdot 10^{-147}:\\
\;\;\;\;angle\_m \cdot \left(\left(a \cdot a\right) \cdot \left(angle\_m \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot b\\
\end{array}
\end{array}
if b < 1.64999999999999994e-147Initial program 86.3%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified86.4%
Taylor expanded in angle around 0
Simplified86.9%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified66.9%
Taylor expanded in b around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6442.5%
Simplified42.5%
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f6447.1%
Applied egg-rr47.1%
if 1.64999999999999994e-147 < b Initial program 72.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6458.4%
Simplified58.4%
Final simplification51.1%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (* b b))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return b * b;
}
angle_m = abs(angle)
real(8) function code(a, b, angle_m)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: angle_m
code = b * b
end function
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return b * b;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return b * b
angle_m = abs(angle) function code(a, b, angle_m) return Float64(b * b) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = b * b; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(b * b), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
b \cdot b
\end{array}
Initial program 81.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6455.8%
Simplified55.8%
herbie shell --seed 2024138
(FPCore (a b angle)
:name "ab-angle->ABCF A"
:precision binary64
(+ (pow (* a (sin (* (/ angle 180.0) PI))) 2.0) (pow (* b (cos (* (/ angle 180.0) PI))) 2.0)))