
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (+ (pow (* a (cos t_0)) 2.0) (pow (* b (sin t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return pow((a * cos(t_0)), 2.0) + pow((b * sin(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return Math.pow((a * Math.cos(t_0)), 2.0) + Math.pow((b * Math.sin(t_0)), 2.0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return math.pow((a * math.cos(t_0)), 2.0) + math.pow((b * math.sin(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64((Float64(a * cos(t_0)) ^ 2.0) + (Float64(b * sin(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((a * cos(t_0)) ^ 2.0) + ((b * sin(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[Power[N[(a * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
{\left(a \cdot \cos t\_0\right)}^{2} + {\left(b \cdot \sin t\_0\right)}^{2}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (+ (pow (* a (cos t_0)) 2.0) (pow (* b (sin t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return pow((a * cos(t_0)), 2.0) + pow((b * sin(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return Math.pow((a * Math.cos(t_0)), 2.0) + Math.pow((b * Math.sin(t_0)), 2.0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return math.pow((a * math.cos(t_0)), 2.0) + math.pow((b * math.sin(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64((Float64(a * cos(t_0)) ^ 2.0) + (Float64(b * sin(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((a * cos(t_0)) ^ 2.0) + ((b * sin(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[Power[N[(a * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
{\left(a \cdot \cos t\_0\right)}^{2} + {\left(b \cdot \sin t\_0\right)}^{2}
\end{array}
\end{array}
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.005555555555555556)))
(t_1 (pow (cbrt t_0) 2.0))
(t_2 (pow t_0 0.16666666666666666)))
(+
(pow
(* a (cos (* t_2 (* t_1 (pow (* t_2 (* t_2 t_1)) 0.16666666666666666)))))
2.0)
(pow (* b (sin t_0)) 2.0))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.005555555555555556);
double t_1 = pow(cbrt(t_0), 2.0);
double t_2 = pow(t_0, 0.16666666666666666);
return pow((a * cos((t_2 * (t_1 * pow((t_2 * (t_2 * t_1)), 0.16666666666666666))))), 2.0) + pow((b * sin(t_0)), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.005555555555555556);
double t_1 = Math.pow(Math.cbrt(t_0), 2.0);
double t_2 = Math.pow(t_0, 0.16666666666666666);
return Math.pow((a * Math.cos((t_2 * (t_1 * Math.pow((t_2 * (t_2 * t_1)), 0.16666666666666666))))), 2.0) + Math.pow((b * Math.sin(t_0)), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.005555555555555556)) t_1 = cbrt(t_0) ^ 2.0 t_2 = t_0 ^ 0.16666666666666666 return Float64((Float64(a * cos(Float64(t_2 * Float64(t_1 * (Float64(t_2 * Float64(t_2 * t_1)) ^ 0.16666666666666666))))) ^ 2.0) + (Float64(b * sin(t_0)) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[t$95$0, 0.16666666666666666], $MachinePrecision]}, N[(N[Power[N[(a * N[Cos[N[(t$95$2 * N[(t$95$1 * N[Power[N[(t$95$2 * N[(t$95$2 * t$95$1), $MachinePrecision]), $MachinePrecision], 0.16666666666666666], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\\
t_1 := {\left(\sqrt[3]{t\_0}\right)}^{2}\\
t_2 := {t\_0}^{0.16666666666666666}\\
{\left(a \cdot \cos \left(t\_2 \cdot \left(t\_1 \cdot {\left(t\_2 \cdot \left(t\_2 \cdot t\_1\right)\right)}^{0.16666666666666666}\right)\right)\right)}^{2} + {\left(b \cdot \sin t\_0\right)}^{2}
\end{array}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
add-cube-cbrt77.2%
pow377.1%
div-inv77.2%
metadata-eval77.2%
Applied egg-rr77.2%
cube-mult77.2%
add-sqr-sqrt42.1%
associate-*l*42.1%
pow1/342.0%
sqrt-pow142.0%
metadata-eval42.0%
pow1/342.2%
sqrt-pow142.2%
metadata-eval42.2%
pow242.2%
Applied egg-rr42.2%
metadata-eval42.2%
div-inv42.2%
add-cbrt-cube31.1%
pow1/331.0%
pow-to-exp31.1%
pow331.1%
log-pow42.2%
div-inv42.2%
metadata-eval42.2%
Applied egg-rr42.2%
*-commutative42.2%
associate-*r*42.2%
metadata-eval42.2%
*-un-lft-identity42.2%
add-exp-log42.2%
metadata-eval42.2%
div-inv42.2%
clear-num42.2%
div-inv42.1%
rem-3cbrt-rft42.1%
Applied egg-rr42.3%
Final simplification42.3%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.005555555555555556))))
(+
(pow (* b (sin t_0)) 2.0)
(pow
(*
a
(cos
(*
(pow t_0 0.16666666666666666)
(*
(pow (cbrt t_0) 2.0)
(pow
(exp (* (* 3.0 (log t_0)) 0.3333333333333333))
0.16666666666666666)))))
2.0))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.005555555555555556);
return pow((b * sin(t_0)), 2.0) + pow((a * cos((pow(t_0, 0.16666666666666666) * (pow(cbrt(t_0), 2.0) * pow(exp(((3.0 * log(t_0)) * 0.3333333333333333)), 0.16666666666666666))))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.005555555555555556);
return Math.pow((b * Math.sin(t_0)), 2.0) + Math.pow((a * Math.cos((Math.pow(t_0, 0.16666666666666666) * (Math.pow(Math.cbrt(t_0), 2.0) * Math.pow(Math.exp(((3.0 * Math.log(t_0)) * 0.3333333333333333)), 0.16666666666666666))))), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.005555555555555556)) return Float64((Float64(b * sin(t_0)) ^ 2.0) + (Float64(a * cos(Float64((t_0 ^ 0.16666666666666666) * Float64((cbrt(t_0) ^ 2.0) * (exp(Float64(Float64(3.0 * log(t_0)) * 0.3333333333333333)) ^ 0.16666666666666666))))) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, N[(N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(N[Power[t$95$0, 0.16666666666666666], $MachinePrecision] * N[(N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[Power[N[Exp[N[(N[(3.0 * N[Log[t$95$0], $MachinePrecision]), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]], $MachinePrecision], 0.16666666666666666], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\\
{\left(b \cdot \sin t\_0\right)}^{2} + {\left(a \cdot \cos \left({t\_0}^{0.16666666666666666} \cdot \left({\left(\sqrt[3]{t\_0}\right)}^{2} \cdot {\left(e^{\left(3 \cdot \log t\_0\right) \cdot 0.3333333333333333}\right)}^{0.16666666666666666}\right)\right)\right)}^{2}
\end{array}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
add-cube-cbrt77.2%
pow377.1%
div-inv77.2%
metadata-eval77.2%
Applied egg-rr77.2%
cube-mult77.2%
add-sqr-sqrt42.1%
associate-*l*42.1%
pow1/342.0%
sqrt-pow142.0%
metadata-eval42.0%
pow1/342.2%
sqrt-pow142.2%
metadata-eval42.2%
pow242.2%
Applied egg-rr42.2%
metadata-eval42.2%
div-inv42.2%
add-cbrt-cube31.1%
pow1/331.0%
pow-to-exp31.1%
pow331.1%
log-pow42.2%
div-inv42.2%
metadata-eval42.2%
Applied egg-rr42.2%
Final simplification42.2%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.005555555555555556))))
(+
(pow (* b (sin t_0)) 2.0)
(pow
(*
a
(cos
(*
(pow t_0 0.16666666666666666)
(*
(pow (cbrt t_0) 2.0)
(pow (expm1 (log1p t_0)) 0.16666666666666666)))))
2.0))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.005555555555555556);
return pow((b * sin(t_0)), 2.0) + pow((a * cos((pow(t_0, 0.16666666666666666) * (pow(cbrt(t_0), 2.0) * pow(expm1(log1p(t_0)), 0.16666666666666666))))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.005555555555555556);
return Math.pow((b * Math.sin(t_0)), 2.0) + Math.pow((a * Math.cos((Math.pow(t_0, 0.16666666666666666) * (Math.pow(Math.cbrt(t_0), 2.0) * Math.pow(Math.expm1(Math.log1p(t_0)), 0.16666666666666666))))), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.005555555555555556)) return Float64((Float64(b * sin(t_0)) ^ 2.0) + (Float64(a * cos(Float64((t_0 ^ 0.16666666666666666) * Float64((cbrt(t_0) ^ 2.0) * (expm1(log1p(t_0)) ^ 0.16666666666666666))))) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, N[(N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(N[Power[t$95$0, 0.16666666666666666], $MachinePrecision] * N[(N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[Power[N[(Exp[N[Log[1 + t$95$0], $MachinePrecision]] - 1), $MachinePrecision], 0.16666666666666666], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\\
{\left(b \cdot \sin t\_0\right)}^{2} + {\left(a \cdot \cos \left({t\_0}^{0.16666666666666666} \cdot \left({\left(\sqrt[3]{t\_0}\right)}^{2} \cdot {\left(\mathsf{expm1}\left(\mathsf{log1p}\left(t\_0\right)\right)\right)}^{0.16666666666666666}\right)\right)\right)}^{2}
\end{array}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
add-cube-cbrt77.2%
pow377.1%
div-inv77.2%
metadata-eval77.2%
Applied egg-rr77.2%
cube-mult77.2%
add-sqr-sqrt42.1%
associate-*l*42.1%
pow1/342.0%
sqrt-pow142.0%
metadata-eval42.0%
pow1/342.2%
sqrt-pow142.2%
metadata-eval42.2%
pow242.2%
Applied egg-rr42.2%
expm1-log1p-u42.2%
Applied egg-rr42.2%
Final simplification42.2%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* PI (* angle_m 0.005555555555555556)))
(t_1 (pow t_0 0.16666666666666666)))
(+
(pow (* b (sin t_0)) 2.0)
(pow (* a (cos (* t_1 (* t_1 (pow (cbrt t_0) 2.0))))) 2.0))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * (angle_m * 0.005555555555555556);
double t_1 = pow(t_0, 0.16666666666666666);
return pow((b * sin(t_0)), 2.0) + pow((a * cos((t_1 * (t_1 * pow(cbrt(t_0), 2.0))))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = Math.PI * (angle_m * 0.005555555555555556);
double t_1 = Math.pow(t_0, 0.16666666666666666);
return Math.pow((b * Math.sin(t_0)), 2.0) + Math.pow((a * Math.cos((t_1 * (t_1 * Math.pow(Math.cbrt(t_0), 2.0))))), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(pi * Float64(angle_m * 0.005555555555555556)) t_1 = t_0 ^ 0.16666666666666666 return Float64((Float64(b * sin(t_0)) ^ 2.0) + (Float64(a * cos(Float64(t_1 * Float64(t_1 * (cbrt(t_0) ^ 2.0))))) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Power[t$95$0, 0.16666666666666666], $MachinePrecision]}, N[(N[Power[N[(b * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(t$95$1 * N[(t$95$1 * N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\\
t_1 := {t\_0}^{0.16666666666666666}\\
{\left(b \cdot \sin t\_0\right)}^{2} + {\left(a \cdot \cos \left(t\_1 \cdot \left(t\_1 \cdot {\left(\sqrt[3]{t\_0}\right)}^{2}\right)\right)\right)}^{2}
\end{array}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
add-cube-cbrt77.2%
pow377.1%
div-inv77.2%
metadata-eval77.2%
Applied egg-rr77.2%
cube-mult77.2%
add-sqr-sqrt42.1%
associate-*l*42.1%
pow1/342.0%
sqrt-pow142.0%
metadata-eval42.0%
pow1/342.2%
sqrt-pow142.2%
metadata-eval42.2%
pow242.2%
Applied egg-rr42.2%
Final simplification42.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* b (sin (* PI (* angle_m 0.005555555555555556)))) 2.0) (pow (* a (cos (/ (* angle_m (cbrt (pow PI 3.0))) 180.0))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((b * sin((((double) M_PI) * (angle_m * 0.005555555555555556)))), 2.0) + pow((a * cos(((angle_m * cbrt(pow(((double) M_PI), 3.0))) / 180.0))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((b * Math.sin((Math.PI * (angle_m * 0.005555555555555556)))), 2.0) + Math.pow((a * Math.cos(((angle_m * Math.cbrt(Math.pow(Math.PI, 3.0))) / 180.0))), 2.0);
}
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(b * sin(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 2.0) + (Float64(a * cos(Float64(Float64(angle_m * cbrt((pi ^ 3.0))) / 180.0))) ^ 2.0)) end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(b * N[Sin[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(N[(angle$95$m * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(b \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)}^{2} + {\left(a \cdot \cos \left(\frac{angle\_m \cdot \sqrt[3]{{\pi}^{3}}}{180}\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
associate-*r/77.3%
Applied egg-rr77.3%
add-cbrt-cube77.3%
pow377.3%
Applied egg-rr77.3%
Final simplification77.3%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* b (sin (* PI (* angle_m 0.005555555555555556)))) 2.0) (pow (* a (cos (* angle_m (* PI 0.005555555555555556)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((b * sin((((double) M_PI) * (angle_m * 0.005555555555555556)))), 2.0) + pow((a * cos((angle_m * (((double) M_PI) * 0.005555555555555556)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((b * Math.sin((Math.PI * (angle_m * 0.005555555555555556)))), 2.0) + Math.pow((a * Math.cos((angle_m * (Math.PI * 0.005555555555555556)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((b * math.sin((math.pi * (angle_m * 0.005555555555555556)))), 2.0) + math.pow((a * math.cos((angle_m * (math.pi * 0.005555555555555556)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(b * sin(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 2.0) + (Float64(a * cos(Float64(angle_m * Float64(pi * 0.005555555555555556)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((b * sin((pi * (angle_m * 0.005555555555555556)))) ^ 2.0) + ((a * cos((angle_m * (pi * 0.005555555555555556)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(b * N[Sin[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(angle$95$m * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(b \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)}^{2} + {\left(a \cdot \cos \left(angle\_m \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around inf 77.3%
associate-*r*77.1%
*-commutative77.1%
associate-*r*77.2%
Simplified77.2%
Final simplification77.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* b (sin (* PI (* angle_m 0.005555555555555556)))) 2.0) (pow (* a (cos (/ PI (/ 180.0 angle_m)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((b * sin((((double) M_PI) * (angle_m * 0.005555555555555556)))), 2.0) + pow((a * cos((((double) M_PI) / (180.0 / angle_m)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((b * Math.sin((Math.PI * (angle_m * 0.005555555555555556)))), 2.0) + Math.pow((a * Math.cos((Math.PI / (180.0 / angle_m)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((b * math.sin((math.pi * (angle_m * 0.005555555555555556)))), 2.0) + math.pow((a * math.cos((math.pi / (180.0 / angle_m)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(b * sin(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 2.0) + (Float64(a * cos(Float64(pi / Float64(180.0 / angle_m)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((b * sin((pi * (angle_m * 0.005555555555555556)))) ^ 2.0) + ((a * cos((pi / (180.0 / angle_m)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(b * N[Sin[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(b \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)}^{2} + {\left(a \cdot \cos \left(\frac{\pi}{\frac{180}{angle\_m}}\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
clear-num77.1%
un-div-inv77.2%
Applied egg-rr77.2%
Final simplification77.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* b (sin (* PI (* angle_m 0.005555555555555556)))) 2.0) (pow (* a (cos (/ (* PI angle_m) 180.0))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((b * sin((((double) M_PI) * (angle_m * 0.005555555555555556)))), 2.0) + pow((a * cos(((((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 Math.pow((b * Math.sin((Math.PI * (angle_m * 0.005555555555555556)))), 2.0) + Math.pow((a * Math.cos(((Math.PI * angle_m) / 180.0))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((b * math.sin((math.pi * (angle_m * 0.005555555555555556)))), 2.0) + math.pow((a * math.cos(((math.pi * angle_m) / 180.0))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(b * sin(Float64(pi * Float64(angle_m * 0.005555555555555556)))) ^ 2.0) + (Float64(a * cos(Float64(Float64(pi * angle_m) / 180.0))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((b * sin((pi * (angle_m * 0.005555555555555556)))) ^ 2.0) + ((a * cos(((pi * angle_m) / 180.0))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(b * N[Sin[N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(a * N[Cos[N[(N[(Pi * angle$95$m), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(b \cdot \sin \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)}^{2} + {\left(a \cdot \cos \left(\frac{\pi \cdot angle\_m}{180}\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
metadata-eval77.1%
div-inv77.1%
associate-*r/77.3%
Applied egg-rr77.3%
Final simplification77.3%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (pow (* b (sin (* 0.005555555555555556 (* PI angle_m)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + pow((b * sin((0.005555555555555556 * (((double) M_PI) * angle_m)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + Math.pow((b * Math.sin((0.005555555555555556 * (Math.PI * angle_m)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + math.pow((b * math.sin((0.005555555555555556 * (math.pi * angle_m)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + (Float64(b * sin(Float64(0.005555555555555556 * Float64(pi * angle_m)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((b * sin((0.005555555555555556 * (pi * angle_m)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[N[(0.005555555555555556 * N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + {\left(b \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\_m\right)\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around inf 76.8%
Final simplification76.8%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (pow (* 0.005555555555555556 (* b (* PI angle_m))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + pow((0.005555555555555556 * (b * (((double) M_PI) * angle_m))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + Math.pow((0.005555555555555556 * (b * (Math.PI * angle_m))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + math.pow((0.005555555555555556 * (b * (math.pi * angle_m))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + (Float64(0.005555555555555556 * Float64(b * Float64(pi * angle_m))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((0.005555555555555556 * (b * (pi * angle_m))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[Power[N[(0.005555555555555556 * N[(b * N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + {\left(0.005555555555555556 \cdot \left(b \cdot \left(\pi \cdot angle\_m\right)\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
unpow271.2%
associate-*r*71.2%
associate-*l*71.1%
*-commutative71.1%
*-commutative71.1%
*-commutative71.1%
associate-*r*71.1%
*-commutative71.1%
metadata-eval71.1%
div-inv71.1%
*-commutative71.1%
associate-*l*71.1%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
*-commutative71.1%
*-commutative71.1%
associate-*l*71.3%
associate-*r*71.2%
associate-*l*71.2%
pow271.2%
associate-*l*71.2%
associate-*r*71.2%
*-commutative71.2%
associate-*l*71.2%
Applied egg-rr71.2%
Final simplification71.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (pow (* angle_m (* b (* PI 0.005555555555555556))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + pow((angle_m * (b * (((double) M_PI) * 0.005555555555555556))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + Math.pow((angle_m * (b * (Math.PI * 0.005555555555555556))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + math.pow((angle_m * (b * (math.pi * 0.005555555555555556))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + (Float64(angle_m * Float64(b * Float64(pi * 0.005555555555555556))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((angle_m * (b * (pi * 0.005555555555555556))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[Power[N[(angle$95$m * N[(b * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + {\left(angle\_m \cdot \left(b \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
Taylor expanded in b around 0 61.2%
associate-*r*61.1%
*-commutative61.1%
unpow261.1%
metadata-eval61.1%
swap-sqr61.5%
associate-*r*61.5%
unpow261.5%
swap-sqr71.3%
*-commutative71.3%
unpow271.3%
swap-sqr71.2%
unpow271.2%
Simplified71.2%
Final simplification71.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (pow (* b (* angle_m (* PI 0.005555555555555556))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + pow((b * (angle_m * (((double) M_PI) * 0.005555555555555556))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + Math.pow((b * (angle_m * (Math.PI * 0.005555555555555556))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + math.pow((b * (angle_m * (math.pi * 0.005555555555555556))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + (Float64(b * Float64(angle_m * Float64(pi * 0.005555555555555556))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((b * (angle_m * (pi * 0.005555555555555556))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[Power[N[(b * N[(angle$95$m * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + {\left(b \cdot \left(angle\_m \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
associate-*r*71.2%
*-commutative71.2%
associate-*r*71.3%
Simplified71.3%
Final simplification71.3%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (* (* 0.005555555555555556 b) (* (* PI angle_m) (* 0.005555555555555556 (* angle_m (* PI b)))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + ((0.005555555555555556 * b) * ((((double) M_PI) * angle_m) * (0.005555555555555556 * (angle_m * (((double) M_PI) * b)))));
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((Math.PI * angle_m) * (0.005555555555555556 * (angle_m * (Math.PI * b)))));
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((math.pi * angle_m) * (0.005555555555555556 * (angle_m * (math.pi * b)))))
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + Float64(Float64(0.005555555555555556 * b) * Float64(Float64(pi * angle_m) * Float64(0.005555555555555556 * Float64(angle_m * Float64(pi * b)))))) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((0.005555555555555556 * b) * ((pi * angle_m) * (0.005555555555555556 * (angle_m * (pi * b))))); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[(N[(0.005555555555555556 * b), $MachinePrecision] * N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(0.005555555555555556 * N[(angle$95$m * N[(Pi * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + \left(0.005555555555555556 \cdot b\right) \cdot \left(\left(\pi \cdot angle\_m\right) \cdot \left(0.005555555555555556 \cdot \left(angle\_m \cdot \left(\pi \cdot b\right)\right)\right)\right)
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
unpow271.2%
associate-*r*71.2%
associate-*l*71.1%
*-commutative71.1%
*-commutative71.1%
*-commutative71.1%
associate-*r*71.1%
*-commutative71.1%
metadata-eval71.1%
div-inv71.1%
*-commutative71.1%
associate-*l*71.1%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
Taylor expanded in angle around 0 71.1%
*-commutative71.1%
Simplified71.1%
Final simplification71.1%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (* (* 0.005555555555555556 b) (* (* PI angle_m) (* (* angle_m b) (/ PI 180.0))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + ((0.005555555555555556 * b) * ((((double) M_PI) * angle_m) * ((angle_m * b) * (((double) M_PI) / 180.0))));
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((Math.PI * angle_m) * ((angle_m * b) * (Math.PI / 180.0))));
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((math.pi * angle_m) * ((angle_m * b) * (math.pi / 180.0))))
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + Float64(Float64(0.005555555555555556 * b) * Float64(Float64(pi * angle_m) * Float64(Float64(angle_m * b) * Float64(pi / 180.0))))) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((0.005555555555555556 * b) * ((pi * angle_m) * ((angle_m * b) * (pi / 180.0)))); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[(N[(0.005555555555555556 * b), $MachinePrecision] * N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(N[(angle$95$m * b), $MachinePrecision] * N[(Pi / 180.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + \left(0.005555555555555556 \cdot b\right) \cdot \left(\left(\pi \cdot angle\_m\right) \cdot \left(\left(angle\_m \cdot b\right) \cdot \frac{\pi}{180}\right)\right)
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
unpow271.2%
associate-*r*71.2%
associate-*l*71.1%
*-commutative71.1%
*-commutative71.1%
*-commutative71.1%
associate-*r*71.1%
*-commutative71.1%
metadata-eval71.1%
div-inv71.1%
*-commutative71.1%
associate-*l*71.1%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
Taylor expanded in angle around 0 71.1%
*-commutative71.1%
associate-*r*71.1%
*-commutative71.1%
associate-*l*71.1%
*-commutative71.1%
metadata-eval71.1%
/-rgt-identity71.1%
associate-/r/71.1%
times-frac71.0%
*-lft-identity71.0%
associate-/l/71.1%
associate-/r/71.1%
/-rgt-identity71.1%
associate-/l*71.0%
associate-*r*71.1%
*-commutative71.1%
associate-*r*71.1%
associate-/l*71.1%
Simplified71.1%
Final simplification71.1%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow a 2.0) (* (* 0.005555555555555556 b) (* (* PI angle_m) (/ b (/ 180.0 (* PI angle_m)))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow(a, 2.0) + ((0.005555555555555556 * b) * ((((double) M_PI) * angle_m) * (b / (180.0 / (((double) M_PI) * angle_m)))));
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((Math.PI * angle_m) * (b / (180.0 / (Math.PI * angle_m)))));
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow(a, 2.0) + ((0.005555555555555556 * b) * ((math.pi * angle_m) * (b / (180.0 / (math.pi * angle_m)))))
angle_m = abs(angle) function code(a, b, angle_m) return Float64((a ^ 2.0) + Float64(Float64(0.005555555555555556 * b) * Float64(Float64(pi * angle_m) * Float64(b / Float64(180.0 / Float64(pi * angle_m)))))) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a ^ 2.0) + ((0.005555555555555556 * b) * ((pi * angle_m) * (b / (180.0 / (pi * angle_m))))); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[a, 2.0], $MachinePrecision] + N[(N[(0.005555555555555556 * b), $MachinePrecision] * N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(b / N[(180.0 / N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{a}^{2} + \left(0.005555555555555556 \cdot b\right) \cdot \left(\left(\pi \cdot angle\_m\right) \cdot \frac{b}{\frac{180}{\pi \cdot angle\_m}}\right)
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
unpow271.2%
associate-*r*71.2%
associate-*l*71.1%
*-commutative71.1%
*-commutative71.1%
*-commutative71.1%
associate-*r*71.1%
*-commutative71.1%
metadata-eval71.1%
div-inv71.1%
*-commutative71.1%
associate-*l*71.1%
div-inv71.1%
metadata-eval71.1%
Applied egg-rr71.1%
associate-*r*71.1%
metadata-eval71.1%
div-inv71.1%
clear-num71.0%
div-inv71.1%
clear-num71.1%
associate-*l/71.1%
*-un-lft-identity71.1%
associate-/l/71.1%
Applied egg-rr71.1%
Final simplification71.1%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (let* ((t_0 (* PI (* (* angle_m 0.005555555555555556) b)))) (+ (pow a 2.0) (* t_0 t_0))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = ((double) M_PI) * ((angle_m * 0.005555555555555556) * b);
return pow(a, 2.0) + (t_0 * t_0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = Math.PI * ((angle_m * 0.005555555555555556) * b);
return Math.pow(a, 2.0) + (t_0 * t_0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = math.pi * ((angle_m * 0.005555555555555556) * b) return math.pow(a, 2.0) + (t_0 * t_0)
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(pi * Float64(Float64(angle_m * 0.005555555555555556) * b)) return Float64((a ^ 2.0) + Float64(t_0 * t_0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) t_0 = pi * ((angle_m * 0.005555555555555556) * b); tmp = (a ^ 2.0) + (t_0 * t_0); end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(N[(angle$95$m * 0.005555555555555556), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, N[(N[Power[a, 2.0], $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \left(\left(angle\_m \cdot 0.005555555555555556\right) \cdot b\right)\\
{a}^{2} + t\_0 \cdot t\_0
\end{array}
\end{array}
Initial program 77.1%
Simplified77.1%
Taylor expanded in angle around 0 76.8%
Taylor expanded in angle around 0 71.2%
unpow271.2%
*-commutative71.2%
associate-*r*71.2%
*-commutative71.2%
metadata-eval71.2%
div-inv71.2%
*-commutative71.2%
associate-*l*71.3%
div-inv71.2%
metadata-eval71.2%
*-commutative71.2%
associate-*r*71.2%
*-commutative71.2%
metadata-eval71.2%
div-inv71.3%
*-commutative71.3%
associate-*l*71.2%
div-inv71.2%
metadata-eval71.2%
Applied egg-rr71.2%
Final simplification71.2%
herbie shell --seed 2024080
(FPCore (a b angle)
:name "ab-angle->ABCF C"
:precision binary64
(+ (pow (* a (cos (* PI (/ angle 180.0)))) 2.0) (pow (* b (sin (* PI (/ angle 180.0)))) 2.0)))