
(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 10 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
(if (<= angle_m 3.4e-9)
(+
(* a a)
(* (* (* angle_m 3.08641975308642e-5) (* b angle_m)) (* b (* PI PI))))
(+
(* a a)
(* (* b b) (- 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 tmp;
if (angle_m <= 3.4e-9) {
tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (((double) M_PI) * ((double) M_PI))));
} else {
tmp = (a * a) + ((b * b) * (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 tmp;
if (angle_m <= 3.4e-9) {
tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (Math.PI * Math.PI)));
} else {
tmp = (a * a) + ((b * b) * (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): tmp = 0 if angle_m <= 3.4e-9: tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (math.pi * math.pi))) else: tmp = (a * a) + ((b * b) * (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) tmp = 0.0 if (angle_m <= 3.4e-9) tmp = Float64(Float64(a * a) + Float64(Float64(Float64(angle_m * 3.08641975308642e-5) * Float64(b * angle_m)) * Float64(b * Float64(pi * pi)))); else tmp = Float64(Float64(a * a) + Float64(Float64(b * b) * 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) tmp = 0.0; if (angle_m <= 3.4e-9) tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (pi * pi))); else tmp = (a * a) + ((b * b) * (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_] := If[LessEqual[angle$95$m, 3.4e-9], N[(N[(a * a), $MachinePrecision] + N[(N[(N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision] * N[(b * angle$95$m), $MachinePrecision]), $MachinePrecision] * N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(N[(b * b), $MachinePrecision] * 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]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;angle\_m \leq 3.4 \cdot 10^{-9}:\\
\;\;\;\;a \cdot a + \left(\left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot angle\_m\right)\right) \cdot \left(b \cdot \left(\pi \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + \left(b \cdot b\right) \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \frac{\pi}{\frac{180}{angle\_m}}\right)\right)\\
\end{array}
\end{array}
if angle < 3.3999999999999998e-9Initial program 85.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6485.0%
Simplified85.0%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified73.9%
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6481.3%
Applied egg-rr81.3%
if 3.3999999999999998e-9 < angle Initial program 63.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6465.2%
Simplified65.2%
associate-*r/N/A
associate-*l/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f6465.1%
Applied egg-rr65.1%
+-commutativeN/A
associate-/r/N/A
pow2N/A
associate-*l*N/A
+-lowering-+.f64N/A
Applied egg-rr65.0%
Final simplification76.9%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (* a a) (pow (* b (sin (* PI (/ angle_m 180.0)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return (a * a) + pow((b * 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 (a * a) + Math.pow((b * Math.sin((Math.PI * (angle_m / 180.0)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return (a * a) + math.pow((b * math.sin((math.pi * (angle_m / 180.0)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64(Float64(a * a) + (Float64(b * sin(Float64(pi * Float64(angle_m / 180.0)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a * a) + ((b * sin((pi * (angle_m / 180.0)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * 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|
\\
a \cdot a + {\left(b \cdot \sin \left(\pi \cdot \frac{angle\_m}{180}\right)\right)}^{2}
\end{array}
Initial program 79.3%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.6%
Simplified79.6%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= angle_m 3.4e-9)
(+
(* a a)
(* (* (* angle_m 3.08641975308642e-5) (* b angle_m)) (* b (* PI PI))))
(+
(* a a)
(*
(* b b)
(+ 0.5 (* (cos (* (* PI angle_m) 0.011111111111111112)) -0.5))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (angle_m <= 3.4e-9) {
tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (((double) M_PI) * ((double) M_PI))));
} else {
tmp = (a * a) + ((b * b) * (0.5 + (cos(((((double) M_PI) * 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 tmp;
if (angle_m <= 3.4e-9) {
tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (Math.PI * Math.PI)));
} else {
tmp = (a * a) + ((b * b) * (0.5 + (Math.cos(((Math.PI * angle_m) * 0.011111111111111112)) * -0.5)));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if angle_m <= 3.4e-9: tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (math.pi * math.pi))) else: tmp = (a * a) + ((b * b) * (0.5 + (math.cos(((math.pi * angle_m) * 0.011111111111111112)) * -0.5))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (angle_m <= 3.4e-9) tmp = Float64(Float64(a * a) + Float64(Float64(Float64(angle_m * 3.08641975308642e-5) * Float64(b * angle_m)) * Float64(b * Float64(pi * pi)))); else tmp = Float64(Float64(a * a) + Float64(Float64(b * b) * Float64(0.5 + Float64(cos(Float64(Float64(pi * angle_m) * 0.011111111111111112)) * -0.5)))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (angle_m <= 3.4e-9) tmp = (a * a) + (((angle_m * 3.08641975308642e-5) * (b * angle_m)) * (b * (pi * pi))); else tmp = (a * a) + ((b * b) * (0.5 + (cos(((pi * angle_m) * 0.011111111111111112)) * -0.5))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[angle$95$m, 3.4e-9], N[(N[(a * a), $MachinePrecision] + N[(N[(N[(angle$95$m * 3.08641975308642e-5), $MachinePrecision] * N[(b * angle$95$m), $MachinePrecision]), $MachinePrecision] * N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(N[(b * b), $MachinePrecision] * N[(0.5 + N[(N[Cos[N[(N[(Pi * 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}
\mathbf{if}\;angle\_m \leq 3.4 \cdot 10^{-9}:\\
\;\;\;\;a \cdot a + \left(\left(angle\_m \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot angle\_m\right)\right) \cdot \left(b \cdot \left(\pi \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + \left(b \cdot b\right) \cdot \left(0.5 + \cos \left(\left(\pi \cdot angle\_m\right) \cdot 0.011111111111111112\right) \cdot -0.5\right)\\
\end{array}
\end{array}
if angle < 3.3999999999999998e-9Initial program 85.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6485.0%
Simplified85.0%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified73.9%
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6481.3%
Applied egg-rr81.3%
if 3.3999999999999998e-9 < angle Initial program 63.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6465.2%
Simplified65.2%
*-commutativeN/A
associate-*r/N/A
unpow-prod-downN/A
pow2N/A
associate-*l/N/A
associate-/r/N/A
associate-*l/N/A
associate-/r/N/A
sqr-sin-aN/A
*-lowering-*.f64N/A
Applied egg-rr65.2%
Final simplification76.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 2.1e+49)
(* a a)
(+
(* a a)
(* 3.08641975308642e-5 (* (* b angle_m) (* angle_m (* b (* PI PI))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 2.1e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * ((b * angle_m) * (angle_m * (b * (((double) M_PI) * ((double) M_PI))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 2.1e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * ((b * angle_m) * (angle_m * (b * (Math.PI * Math.PI)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 2.1e+49: tmp = a * a else: tmp = (a * a) + (3.08641975308642e-5 * ((b * angle_m) * (angle_m * (b * (math.pi * math.pi))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 2.1e+49) tmp = Float64(a * a); else tmp = Float64(Float64(a * a) + Float64(3.08641975308642e-5 * Float64(Float64(b * angle_m) * Float64(angle_m * Float64(b * Float64(pi * pi)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 2.1e+49) tmp = a * a; else tmp = (a * a) + (3.08641975308642e-5 * ((b * angle_m) * (angle_m * (b * (pi * pi))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 2.1e+49], N[(a * a), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(3.08641975308642e-5 * N[(N[(b * angle$95$m), $MachinePrecision] * N[(angle$95$m * N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.1 \cdot 10^{+49}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + 3.08641975308642 \cdot 10^{-5} \cdot \left(\left(b \cdot angle\_m\right) \cdot \left(angle\_m \cdot \left(b \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 2.10000000000000011e49Initial program 75.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6462.7%
Simplified62.7%
if 2.10000000000000011e49 < b Initial program 92.6%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified74.9%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6491.6%
Applied egg-rr91.6%
Final simplification69.1%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 1.46e+49)
(* a a)
(+
(* a a)
(* 3.08641975308642e-5 (* angle_m (* b (* (* b angle_m) (* PI PI))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.46e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (b * ((b * angle_m) * (((double) M_PI) * ((double) M_PI))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.46e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (b * ((b * angle_m) * (Math.PI * Math.PI)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.46e+49: tmp = a * a else: tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (b * ((b * angle_m) * (math.pi * math.pi))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.46e+49) tmp = Float64(a * a); else tmp = Float64(Float64(a * a) + Float64(3.08641975308642e-5 * Float64(angle_m * Float64(b * Float64(Float64(b * angle_m) * Float64(pi * pi)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 1.46e+49) tmp = a * a; else tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (b * ((b * angle_m) * (pi * pi))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.46e+49], N[(a * a), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(3.08641975308642e-5 * N[(angle$95$m * N[(b * N[(N[(b * angle$95$m), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.46 \cdot 10^{+49}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + 3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot \left(b \cdot \left(\left(b \cdot angle\_m\right) \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.46000000000000008e49Initial program 75.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6462.7%
Simplified62.7%
if 1.46000000000000008e49 < b Initial program 92.6%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified74.9%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6488.3%
Applied egg-rr88.3%
Final simplification68.4%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 1.8e+49)
(* a a)
(+
(* a a)
(* 3.08641975308642e-5 (* angle_m (* PI (* (* b angle_m) (* b PI))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.8e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (((double) M_PI) * ((b * angle_m) * (b * ((double) M_PI))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.8e+49) {
tmp = a * a;
} else {
tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (Math.PI * ((b * angle_m) * (b * Math.PI)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.8e+49: tmp = a * a else: tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (math.pi * ((b * angle_m) * (b * math.pi))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.8e+49) tmp = Float64(a * a); else tmp = Float64(Float64(a * a) + Float64(3.08641975308642e-5 * Float64(angle_m * Float64(pi * Float64(Float64(b * angle_m) * Float64(b * pi)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 1.8e+49) tmp = a * a; else tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (pi * ((b * angle_m) * (b * pi))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.8e+49], N[(a * a), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(3.08641975308642e-5 * N[(angle$95$m * N[(Pi * N[(N[(b * angle$95$m), $MachinePrecision] * N[(b * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.8 \cdot 10^{+49}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + 3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot \left(\pi \cdot \left(\left(b \cdot angle\_m\right) \cdot \left(b \cdot \pi\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.79999999999999998e49Initial program 75.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6462.7%
Simplified62.7%
if 1.79999999999999998e49 < b Initial program 92.6%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified74.9%
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6488.2%
Applied egg-rr88.2%
Final simplification68.4%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 5e+158) (* a a) (* angle_m (* angle_m (* 3.08641975308642e-5 (* b (* b (* PI PI))))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 5e+158) {
tmp = a * a;
} else {
tmp = angle_m * (angle_m * (3.08641975308642e-5 * (b * (b * (((double) M_PI) * ((double) M_PI))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 5e+158) {
tmp = a * a;
} else {
tmp = angle_m * (angle_m * (3.08641975308642e-5 * (b * (b * (Math.PI * Math.PI)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 5e+158: tmp = a * a else: tmp = angle_m * (angle_m * (3.08641975308642e-5 * (b * (b * (math.pi * math.pi))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 5e+158) tmp = Float64(a * a); else tmp = Float64(angle_m * Float64(angle_m * Float64(3.08641975308642e-5 * Float64(b * Float64(b * Float64(pi * pi)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 5e+158) tmp = a * a; else tmp = angle_m * (angle_m * (3.08641975308642e-5 * (b * (b * (pi * pi))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 5e+158], N[(a * a), $MachinePrecision], N[(angle$95$m * N[(angle$95$m * N[(3.08641975308642e-5 * N[(b * N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 5 \cdot 10^{+158}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;angle\_m \cdot \left(angle\_m \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(b \cdot \left(b \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 4.9999999999999996e158Initial program 75.9%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6461.6%
Simplified61.6%
if 4.9999999999999996e158 < b Initial program 99.9%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified78.7%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/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.f6472.2%
Simplified72.2%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6478.7%
Applied egg-rr78.7%
Final simplification64.0%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 2.4e+154) (* a a) (* b (* (* b (* 3.08641975308642e-5 (* PI PI))) (* angle_m angle_m)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 2.4e+154) {
tmp = a * a;
} else {
tmp = b * ((b * (3.08641975308642e-5 * (((double) M_PI) * ((double) M_PI)))) * (angle_m * angle_m));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 2.4e+154) {
tmp = a * a;
} else {
tmp = b * ((b * (3.08641975308642e-5 * (Math.PI * Math.PI))) * (angle_m * angle_m));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 2.4e+154: tmp = a * a else: tmp = b * ((b * (3.08641975308642e-5 * (math.pi * math.pi))) * (angle_m * angle_m)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 2.4e+154) tmp = Float64(a * a); else tmp = Float64(b * Float64(Float64(b * Float64(3.08641975308642e-5 * Float64(pi * pi))) * Float64(angle_m * angle_m))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 2.4e+154) tmp = a * a; else tmp = b * ((b * (3.08641975308642e-5 * (pi * pi))) * (angle_m * angle_m)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 2.4e+154], N[(a * a), $MachinePrecision], N[(b * N[(N[(b * N[(3.08641975308642e-5 * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(angle$95$m * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.4 \cdot 10^{+154}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(\left(b \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(\pi \cdot \pi\right)\right)\right) \cdot \left(angle\_m \cdot angle\_m\right)\right)\\
\end{array}
\end{array}
if b < 2.40000000000000015e154Initial program 75.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6461.8%
Simplified61.8%
if 2.40000000000000015e154 < b Initial program 99.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified76.6%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/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.f6470.3%
Simplified70.3%
*-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-*.f6471.1%
Applied egg-rr71.1%
Final simplification63.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (* a a) (* 3.08641975308642e-5 (* angle_m (* angle_m (* b (* b (* PI PI))))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return (a * a) + (3.08641975308642e-5 * (angle_m * (angle_m * (b * (b * (((double) M_PI) * ((double) M_PI)))))));
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return (a * a) + (3.08641975308642e-5 * (angle_m * (angle_m * (b * (b * (Math.PI * Math.PI))))));
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return (a * a) + (3.08641975308642e-5 * (angle_m * (angle_m * (b * (b * (math.pi * math.pi))))))
angle_m = abs(angle) function code(a, b, angle_m) return Float64(Float64(a * a) + Float64(3.08641975308642e-5 * Float64(angle_m * Float64(angle_m * Float64(b * Float64(b * Float64(pi * pi))))))) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (a * a) + (3.08641975308642e-5 * (angle_m * (angle_m * (b * (b * (pi * pi)))))); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[(a * a), $MachinePrecision] + N[(3.08641975308642e-5 * N[(angle$95$m * N[(angle$95$m * N[(b * N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
a \cdot a + 3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot \left(angle\_m \cdot \left(b \cdot \left(b \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\right)
\end{array}
Initial program 79.3%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.6%
Simplified79.6%
Taylor expanded in angle around 0
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified70.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (* a a))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return a * a;
}
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 = a * a
end function
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return a * a;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return a * a
angle_m = abs(angle) function code(a, b, angle_m) return Float64(a * a) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = a * a; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(a * a), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
a \cdot a
\end{array}
Initial program 79.3%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6456.8%
Simplified56.8%
herbie shell --seed 2024160
(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)))