
(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 15 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 (+ (pow (* a (cos (* PI (exp (- (log angle_m) (log 180.0)))))) 2.0) (pow (* b (sin (* (/ PI 180.0) (/ 1.0 (/ 1.0 angle_m))))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((a * cos((((double) M_PI) * exp((log(angle_m) - log(180.0)))))), 2.0) + pow((b * sin(((((double) M_PI) / 180.0) * (1.0 / (1.0 / angle_m))))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((a * Math.cos((Math.PI * Math.exp((Math.log(angle_m) - Math.log(180.0)))))), 2.0) + Math.pow((b * Math.sin(((Math.PI / 180.0) * (1.0 / (1.0 / angle_m))))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((a * math.cos((math.pi * math.exp((math.log(angle_m) - math.log(180.0)))))), 2.0) + math.pow((b * math.sin(((math.pi / 180.0) * (1.0 / (1.0 / angle_m))))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(a * cos(Float64(pi * exp(Float64(log(angle_m) - log(180.0)))))) ^ 2.0) + (Float64(b * sin(Float64(Float64(pi / 180.0) * Float64(1.0 / Float64(1.0 / angle_m))))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((a * cos((pi * exp((log(angle_m) - log(180.0)))))) ^ 2.0) + ((b * sin(((pi / 180.0) * (1.0 / (1.0 / angle_m))))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(a * N[Cos[N[(Pi * N[Exp[N[(N[Log[angle$95$m], $MachinePrecision] - N[Log[180.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[N[(N[(Pi / 180.0), $MachinePrecision] * N[(1.0 / N[(1.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(a \cdot \cos \left(\pi \cdot e^{\log angle\_m - \log 180}\right)\right)}^{2} + {\left(b \cdot \sin \left(\frac{\pi}{180} \cdot \frac{1}{\frac{1}{angle\_m}}\right)\right)}^{2}
\end{array}
Initial program 79.5%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
associate-*r/N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6479.6
Applied rewrites79.6%
lift-/.f64N/A
clear-numN/A
inv-powN/A
pow-to-expN/A
lower-exp.f64N/A
lower-*.f64N/A
lower-log.f64N/A
lower-/.f6444.7
Applied rewrites44.7%
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
log-powN/A
inv-powN/A
lift-/.f64N/A
clear-numN/A
log-divN/A
lower--.f64N/A
lower-log.f64N/A
lower-log.f6444.7
Applied rewrites44.7%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* a (cos (* PI (/ angle_m 180.0)))) 2.0) (pow (* b (sin (/ (* PI angle_m) 180.0))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((a * cos((((double) M_PI) * (angle_m / 180.0)))), 2.0) + 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 Math.pow((a * Math.cos((Math.PI * (angle_m / 180.0)))), 2.0) + 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 math.pow((a * math.cos((math.pi * (angle_m / 180.0)))), 2.0) + 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 * cos(Float64(pi * Float64(angle_m / 180.0)))) ^ 2.0) + (Float64(b * sin(Float64(Float64(pi * angle_m) / 180.0))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((a * cos((pi * (angle_m / 180.0)))) ^ 2.0) + ((b * sin(((pi * angle_m) / 180.0))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(a * N[Cos[N[(Pi * N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[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(a \cdot \cos \left(\pi \cdot \frac{angle\_m}{180}\right)\right)}^{2} + {\left(b \cdot \sin \left(\frac{\pi \cdot angle\_m}{180}\right)\right)}^{2}
\end{array}
Initial program 79.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6479.6
Applied rewrites79.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* a (cos (* PI (/ angle_m 180.0)))) 2.0) (pow (* b (sin (* angle_m (* PI 0.005555555555555556)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((a * cos((((double) M_PI) * (angle_m / 180.0)))), 2.0) + pow((b * sin((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 * Math.cos((Math.PI * (angle_m / 180.0)))), 2.0) + Math.pow((b * Math.sin((angle_m * (Math.PI * 0.005555555555555556)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((a * math.cos((math.pi * (angle_m / 180.0)))), 2.0) + math.pow((b * math.sin((angle_m * (math.pi * 0.005555555555555556)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(a * cos(Float64(pi * Float64(angle_m / 180.0)))) ^ 2.0) + (Float64(b * sin(Float64(angle_m * Float64(pi * 0.005555555555555556)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((a * cos((pi * (angle_m / 180.0)))) ^ 2.0) + ((b * sin((angle_m * (pi * 0.005555555555555556)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(a * N[Cos[N[(Pi * N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Sin[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(a \cdot \cos \left(\pi \cdot \frac{angle\_m}{180}\right)\right)}^{2} + {\left(b \cdot \sin \left(angle\_m \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}
\end{array}
Initial program 79.5%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval79.6
Applied rewrites79.6%
Final simplification79.6%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* b (sin (/ (* PI angle_m) 180.0))) 2.0) (* a a)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((b * sin(((((double) M_PI) * angle_m) / 180.0))), 2.0) + (a * a);
}
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) / 180.0))), 2.0) + (a * a);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((b * math.sin(((math.pi * angle_m) / 180.0))), 2.0) + (a * a)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(b * sin(Float64(Float64(pi * angle_m) / 180.0))) ^ 2.0) + Float64(a * a)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((b * sin(((pi * angle_m) / 180.0))) ^ 2.0) + (a * a); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(b * N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[(a * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(b \cdot \sin \left(\frac{\pi \cdot angle\_m}{180}\right)\right)}^{2} + a \cdot a
\end{array}
Initial program 79.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6479.6
Applied rewrites79.6%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6479.2
Applied rewrites79.2%
Final simplification79.2%
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.5%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6479.1
Applied rewrites79.1%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0 (* 0.5 (cos (* 2.0 (* PI (* angle_m 0.005555555555555556)))))))
(if (<= (/ angle_m 180.0) 2e+33)
(fma
(* (* b (* PI PI)) (* (* angle_m angle_m) 3.08641975308642e-5))
b
(* a (* a (+ 0.5 t_0))))
(/ 1.0 (/ 1.0 (fma a (* a 1.0) (* b (* b (- 0.5 t_0)))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = 0.5 * cos((2.0 * (((double) M_PI) * (angle_m * 0.005555555555555556))));
double tmp;
if ((angle_m / 180.0) <= 2e+33) {
tmp = fma(((b * (((double) M_PI) * ((double) M_PI))) * ((angle_m * angle_m) * 3.08641975308642e-5)), b, (a * (a * (0.5 + t_0))));
} else {
tmp = 1.0 / (1.0 / fma(a, (a * 1.0), (b * (b * (0.5 - t_0)))));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(0.5 * cos(Float64(2.0 * Float64(pi * Float64(angle_m * 0.005555555555555556))))) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+33) tmp = fma(Float64(Float64(b * Float64(pi * pi)) * Float64(Float64(angle_m * angle_m) * 3.08641975308642e-5)), b, Float64(a * Float64(a * Float64(0.5 + t_0)))); else tmp = Float64(1.0 / Float64(1.0 / fma(a, Float64(a * 1.0), Float64(b * Float64(b * Float64(0.5 - t_0)))))); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(0.5 * N[Cos[N[(2.0 * N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+33], N[(N[(N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] * N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision] * b + N[(a * N[(a * N[(0.5 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(1.0 / N[(a * N[(a * 1.0), $MachinePrecision] + N[(b * N[(b * N[(0.5 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := 0.5 \cdot \cos \left(2 \cdot \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)\\
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+33}:\\
\;\;\;\;\mathsf{fma}\left(\left(b \cdot \left(\pi \cdot \pi\right)\right) \cdot \left(\left(angle\_m \cdot angle\_m\right) \cdot 3.08641975308642 \cdot 10^{-5}\right), b, a \cdot \left(a \cdot \left(0.5 + t\_0\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{1}{\mathsf{fma}\left(a, a \cdot 1, b \cdot \left(b \cdot \left(0.5 - t\_0\right)\right)\right)}}\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.9999999999999999e33Initial program 87.6%
Applied rewrites62.0%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6480.3
Applied rewrites80.3%
if 1.9999999999999999e33 < (/.f64 angle #s(literal 180 binary64)) Initial program 57.6%
Applied rewrites57.4%
Taylor expanded in angle around 0
Applied rewrites57.8%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 4.2e-84)
(* (* a a) (fma 0.5 (cos (* angle_m (* PI 0.011111111111111112))) 0.5))
(fma
(* (* b (* PI PI)) (* (* angle_m angle_m) 3.08641975308642e-5))
b
(*
a
(*
a
(+
0.5
(* 0.5 (cos (* 2.0 (* PI (* angle_m 0.005555555555555556)))))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 4.2e-84) {
tmp = (a * a) * fma(0.5, cos((angle_m * (((double) M_PI) * 0.011111111111111112))), 0.5);
} else {
tmp = fma(((b * (((double) M_PI) * ((double) M_PI))) * ((angle_m * angle_m) * 3.08641975308642e-5)), b, (a * (a * (0.5 + (0.5 * cos((2.0 * (((double) M_PI) * (angle_m * 0.005555555555555556)))))))));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 4.2e-84) tmp = Float64(Float64(a * a) * fma(0.5, cos(Float64(angle_m * Float64(pi * 0.011111111111111112))), 0.5)); else tmp = fma(Float64(Float64(b * Float64(pi * pi)) * Float64(Float64(angle_m * angle_m) * 3.08641975308642e-5)), b, Float64(a * Float64(a * Float64(0.5 + Float64(0.5 * cos(Float64(2.0 * Float64(pi * Float64(angle_m * 0.005555555555555556))))))))); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 4.2e-84], N[(N[(a * a), $MachinePrecision] * N[(0.5 * N[Cos[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] * N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision] * b + N[(a * N[(a * N[(0.5 + N[(0.5 * N[Cos[N[(2.0 * N[(Pi * N[(angle$95$m * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.2 \cdot 10^{-84}:\\
\;\;\;\;\left(a \cdot a\right) \cdot \mathsf{fma}\left(0.5, \cos \left(angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)\right), 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(b \cdot \left(\pi \cdot \pi\right)\right) \cdot \left(\left(angle\_m \cdot angle\_m\right) \cdot 3.08641975308642 \cdot 10^{-5}\right), b, a \cdot \left(a \cdot \left(0.5 + 0.5 \cdot \cos \left(2 \cdot \left(\pi \cdot \left(angle\_m \cdot 0.005555555555555556\right)\right)\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 4.19999999999999996e-84Initial program 77.3%
Applied rewrites72.1%
Taylor expanded in b around 0
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6459.3
Applied rewrites59.3%
if 4.19999999999999996e-84 < b Initial program 85.6%
Applied rewrites70.6%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6479.7
Applied rewrites79.7%
Final simplification64.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 4.2e-84)
(* (* a a) (fma 0.5 (cos (* angle_m (* PI 0.011111111111111112))) 0.5))
(fma
(* (* angle_m angle_m) (* b (* (* PI PI) 3.08641975308642e-5)))
b
(* (* a a) (fma 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 (b <= 4.2e-84) {
tmp = (a * a) * fma(0.5, cos((angle_m * (((double) M_PI) * 0.011111111111111112))), 0.5);
} else {
tmp = fma(((angle_m * angle_m) * (b * ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5))), b, ((a * a) * fma(0.5, cos(((((double) M_PI) * angle_m) * 0.011111111111111112)), 0.5)));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 4.2e-84) tmp = Float64(Float64(a * a) * fma(0.5, cos(Float64(angle_m * Float64(pi * 0.011111111111111112))), 0.5)); else tmp = fma(Float64(Float64(angle_m * angle_m) * Float64(b * Float64(Float64(pi * pi) * 3.08641975308642e-5))), b, Float64(Float64(a * a) * fma(0.5, cos(Float64(Float64(pi * angle_m) * 0.011111111111111112)), 0.5))); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 4.2e-84], N[(N[(a * a), $MachinePrecision] * N[(0.5 * N[Cos[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * N[(b * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b + N[(N[(a * a), $MachinePrecision] * N[(0.5 * N[Cos[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.2 \cdot 10^{-84}:\\
\;\;\;\;\left(a \cdot a\right) \cdot \mathsf{fma}\left(0.5, \cos \left(angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)\right), 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(angle\_m \cdot angle\_m\right) \cdot \left(b \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right), b, \left(a \cdot a\right) \cdot \mathsf{fma}\left(0.5, \cos \left(\left(\pi \cdot angle\_m\right) \cdot 0.011111111111111112\right), 0.5\right)\right)\\
\end{array}
\end{array}
if b < 4.19999999999999996e-84Initial program 77.3%
Applied rewrites72.1%
Taylor expanded in b around 0
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6459.3
Applied rewrites59.3%
if 4.19999999999999996e-84 < b Initial program 85.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6485.7
Applied rewrites85.7%
Applied rewrites82.8%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f6479.6
Applied rewrites79.6%
Final simplification64.8%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 4.2e-84)
(* (* a a) (fma 0.5 (cos (* angle_m (* PI 0.011111111111111112))) 0.5))
(if (<= b 1.2e+147)
(fma
(* angle_m angle_m)
(* (* PI PI) (* b (* b 3.08641975308642e-5)))
(* a a))
(fma
(*
(* PI angle_m)
(*
PI
(fma a (* a -3.08641975308642e-5) (* 3.08641975308642e-5 (* b b)))))
angle_m
(* a a)))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 4.2e-84) {
tmp = (a * a) * fma(0.5, cos((angle_m * (((double) M_PI) * 0.011111111111111112))), 0.5);
} else if (b <= 1.2e+147) {
tmp = fma((angle_m * angle_m), ((((double) M_PI) * ((double) M_PI)) * (b * (b * 3.08641975308642e-5))), (a * a));
} else {
tmp = fma(((((double) M_PI) * angle_m) * (((double) M_PI) * fma(a, (a * -3.08641975308642e-5), (3.08641975308642e-5 * (b * b))))), angle_m, (a * a));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 4.2e-84) tmp = Float64(Float64(a * a) * fma(0.5, cos(Float64(angle_m * Float64(pi * 0.011111111111111112))), 0.5)); elseif (b <= 1.2e+147) tmp = fma(Float64(angle_m * angle_m), Float64(Float64(pi * pi) * Float64(b * Float64(b * 3.08641975308642e-5))), Float64(a * a)); else tmp = fma(Float64(Float64(pi * angle_m) * Float64(pi * fma(a, Float64(a * -3.08641975308642e-5), Float64(3.08641975308642e-5 * Float64(b * b))))), angle_m, Float64(a * a)); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 4.2e-84], N[(N[(a * a), $MachinePrecision] * N[(0.5 * N[Cos[N[(angle$95$m * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.2e+147], N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * N[(b * N[(b * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(Pi * N[(a * N[(a * -3.08641975308642e-5), $MachinePrecision] + N[(3.08641975308642e-5 * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * angle$95$m + N[(a * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.2 \cdot 10^{-84}:\\
\;\;\;\;\left(a \cdot a\right) \cdot \mathsf{fma}\left(0.5, \cos \left(angle\_m \cdot \left(\pi \cdot 0.011111111111111112\right)\right), 0.5\right)\\
\mathbf{elif}\;b \leq 1.2 \cdot 10^{+147}:\\
\;\;\;\;\mathsf{fma}\left(angle\_m \cdot angle\_m, \left(\pi \cdot \pi\right) \cdot \left(b \cdot \left(b \cdot 3.08641975308642 \cdot 10^{-5}\right)\right), a \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\pi \cdot angle\_m\right) \cdot \left(\pi \cdot \mathsf{fma}\left(a, a \cdot -3.08641975308642 \cdot 10^{-5}, 3.08641975308642 \cdot 10^{-5} \cdot \left(b \cdot b\right)\right)\right), angle\_m, a \cdot a\right)\\
\end{array}
\end{array}
if b < 4.19999999999999996e-84Initial program 77.3%
Applied rewrites72.1%
Taylor expanded in b around 0
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6459.3
Applied rewrites59.3%
if 4.19999999999999996e-84 < b < 1.20000000000000001e147Initial program 77.7%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6470.3
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval70.8
Applied rewrites70.8%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites40.2%
Taylor expanded in a around 0
Applied rewrites74.8%
if 1.20000000000000001e147 < b Initial program 95.0%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6471.7
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval71.7
Applied rewrites71.7%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites60.4%
Applied rewrites79.4%
Final simplification64.1%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 4.2e-84)
(* a a)
(if (<= b 1.2e+147)
(fma
(* angle_m angle_m)
(* (* PI PI) (* b (* b 3.08641975308642e-5)))
(* a a))
(fma
(*
(* PI angle_m)
(*
PI
(fma a (* a -3.08641975308642e-5) (* 3.08641975308642e-5 (* b b)))))
angle_m
(* a a)))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 4.2e-84) {
tmp = a * a;
} else if (b <= 1.2e+147) {
tmp = fma((angle_m * angle_m), ((((double) M_PI) * ((double) M_PI)) * (b * (b * 3.08641975308642e-5))), (a * a));
} else {
tmp = fma(((((double) M_PI) * angle_m) * (((double) M_PI) * fma(a, (a * -3.08641975308642e-5), (3.08641975308642e-5 * (b * b))))), angle_m, (a * a));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 4.2e-84) tmp = Float64(a * a); elseif (b <= 1.2e+147) tmp = fma(Float64(angle_m * angle_m), Float64(Float64(pi * pi) * Float64(b * Float64(b * 3.08641975308642e-5))), Float64(a * a)); else tmp = fma(Float64(Float64(pi * angle_m) * Float64(pi * fma(a, Float64(a * -3.08641975308642e-5), Float64(3.08641975308642e-5 * Float64(b * b))))), angle_m, Float64(a * a)); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 4.2e-84], N[(a * a), $MachinePrecision], If[LessEqual[b, 1.2e+147], N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * N[(b * N[(b * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(Pi * angle$95$m), $MachinePrecision] * N[(Pi * N[(a * N[(a * -3.08641975308642e-5), $MachinePrecision] + N[(3.08641975308642e-5 * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * angle$95$m + N[(a * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.2 \cdot 10^{-84}:\\
\;\;\;\;a \cdot a\\
\mathbf{elif}\;b \leq 1.2 \cdot 10^{+147}:\\
\;\;\;\;\mathsf{fma}\left(angle\_m \cdot angle\_m, \left(\pi \cdot \pi\right) \cdot \left(b \cdot \left(b \cdot 3.08641975308642 \cdot 10^{-5}\right)\right), a \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\pi \cdot angle\_m\right) \cdot \left(\pi \cdot \mathsf{fma}\left(a, a \cdot -3.08641975308642 \cdot 10^{-5}, 3.08641975308642 \cdot 10^{-5} \cdot \left(b \cdot b\right)\right)\right), angle\_m, a \cdot a\right)\\
\end{array}
\end{array}
if b < 4.19999999999999996e-84Initial program 77.3%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6458.7
Applied rewrites58.7%
if 4.19999999999999996e-84 < b < 1.20000000000000001e147Initial program 77.7%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6470.3
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval70.8
Applied rewrites70.8%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites40.2%
Taylor expanded in a around 0
Applied rewrites74.8%
if 1.20000000000000001e147 < b Initial program 95.0%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6471.7
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval71.7
Applied rewrites71.7%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites60.4%
Applied rewrites79.4%
Final simplification63.7%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= b 4.2e-84)
(* a a)
(if (<= b 8.2e+155)
(fma
(* angle_m angle_m)
(* (* PI PI) (* b (* b 3.08641975308642e-5)))
(* a a))
(* (* (* PI PI) 3.08641975308642e-5) (* (* angle_m b) (* angle_m b))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 4.2e-84) {
tmp = a * a;
} else if (b <= 8.2e+155) {
tmp = fma((angle_m * angle_m), ((((double) M_PI) * ((double) M_PI)) * (b * (b * 3.08641975308642e-5))), (a * a));
} else {
tmp = ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * ((angle_m * b) * (angle_m * b));
}
return tmp;
}
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 4.2e-84) tmp = Float64(a * a); elseif (b <= 8.2e+155) tmp = fma(Float64(angle_m * angle_m), Float64(Float64(pi * pi) * Float64(b * Float64(b * 3.08641975308642e-5))), Float64(a * a)); else tmp = Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(Float64(angle_m * b) * Float64(angle_m * b))); end return tmp end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 4.2e-84], N[(a * a), $MachinePrecision], If[LessEqual[b, 8.2e+155], N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * N[(b * N[(b * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(N[(angle$95$m * b), $MachinePrecision] * N[(angle$95$m * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.2 \cdot 10^{-84}:\\
\;\;\;\;a \cdot a\\
\mathbf{elif}\;b \leq 8.2 \cdot 10^{+155}:\\
\;\;\;\;\mathsf{fma}\left(angle\_m \cdot angle\_m, \left(\pi \cdot \pi\right) \cdot \left(b \cdot \left(b \cdot 3.08641975308642 \cdot 10^{-5}\right)\right), a \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\left(angle\_m \cdot b\right) \cdot \left(angle\_m \cdot b\right)\right)\\
\end{array}
\end{array}
if b < 4.19999999999999996e-84Initial program 77.3%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6458.7
Applied rewrites58.7%
if 4.19999999999999996e-84 < b < 8.1999999999999996e155Initial program 75.5%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6467.6
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval68.0
Applied rewrites68.0%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites37.9%
Taylor expanded in a around 0
Applied rewrites70.0%
if 8.1999999999999996e155 < b Initial program 99.9%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6475.8
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval75.8
Applied rewrites75.8%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites65.8%
Taylor expanded in a around 0
Applied rewrites76.6%
Applied rewrites83.4%
Final simplification63.3%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 1.75e+156) (* a a) (* (* (* PI PI) 3.08641975308642e-5) (* (* angle_m b) (* angle_m b)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e+156) {
tmp = a * a;
} else {
tmp = ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * ((angle_m * b) * (angle_m * b));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e+156) {
tmp = a * a;
} else {
tmp = ((Math.PI * Math.PI) * 3.08641975308642e-5) * ((angle_m * b) * (angle_m * b));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.75e+156: tmp = a * a else: tmp = ((math.pi * math.pi) * 3.08641975308642e-5) * ((angle_m * b) * (angle_m * b)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.75e+156) tmp = Float64(a * a); else tmp = Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(Float64(angle_m * b) * Float64(angle_m * b))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (b <= 1.75e+156) tmp = a * a; else tmp = ((pi * pi) * 3.08641975308642e-5) * ((angle_m * b) * (angle_m * b)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.75e+156], N[(a * a), $MachinePrecision], N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(N[(angle$95$m * b), $MachinePrecision] * N[(angle$95$m * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.75 \cdot 10^{+156}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(\left(angle\_m \cdot b\right) \cdot \left(angle\_m \cdot b\right)\right)\\
\end{array}
\end{array}
if b < 1.7500000000000002e156Initial program 77.0%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6459.8
Applied rewrites59.8%
if 1.7500000000000002e156 < b Initial program 99.9%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6474.9
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval74.9
Applied rewrites74.9%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites68.1%
Taylor expanded in a around 0
Applied rewrites79.2%
Applied rewrites86.3%
Final simplification62.7%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 1.75e+156) (* a a) (* (* angle_m b) (* angle_m (* b (* PI (* PI 3.08641975308642e-5)))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e+156) {
tmp = a * a;
} else {
tmp = (angle_m * b) * (angle_m * (b * (((double) M_PI) * (((double) M_PI) * 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+156) {
tmp = a * a;
} else {
tmp = (angle_m * b) * (angle_m * (b * (Math.PI * (Math.PI * 3.08641975308642e-5))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.75e+156: tmp = a * a else: tmp = (angle_m * b) * (angle_m * (b * (math.pi * (math.pi * 3.08641975308642e-5)))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.75e+156) tmp = Float64(a * a); else tmp = Float64(Float64(angle_m * b) * Float64(angle_m * Float64(b * Float64(pi * Float64(pi * 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+156) tmp = a * a; else tmp = (angle_m * b) * (angle_m * (b * (pi * (pi * 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+156], N[(a * a), $MachinePrecision], N[(N[(angle$95$m * b), $MachinePrecision] * N[(angle$95$m * N[(b * N[(Pi * N[(Pi * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.75 \cdot 10^{+156}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot b\right) \cdot \left(angle\_m \cdot \left(b \cdot \left(\pi \cdot \left(\pi \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.7500000000000002e156Initial program 77.0%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6459.8
Applied rewrites59.8%
if 1.7500000000000002e156 < b Initial program 99.9%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6474.9
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval74.9
Applied rewrites74.9%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites68.1%
Taylor expanded in a around 0
Applied rewrites79.2%
Applied rewrites86.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= b 1.75e+156) (* a a) (* PI (* (* PI 3.08641975308642e-5) (* b (* b (* angle_m angle_m)))))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (b <= 1.75e+156) {
tmp = a * a;
} else {
tmp = ((double) M_PI) * ((((double) M_PI) * 3.08641975308642e-5) * (b * (b * (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 <= 1.75e+156) {
tmp = a * a;
} else {
tmp = Math.PI * ((Math.PI * 3.08641975308642e-5) * (b * (b * (angle_m * angle_m))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if b <= 1.75e+156: tmp = a * a else: tmp = math.pi * ((math.pi * 3.08641975308642e-5) * (b * (b * (angle_m * angle_m)))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (b <= 1.75e+156) tmp = Float64(a * a); else tmp = Float64(pi * Float64(Float64(pi * 3.08641975308642e-5) * Float64(b * Float64(b * 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 <= 1.75e+156) tmp = a * a; else tmp = pi * ((pi * 3.08641975308642e-5) * (b * (b * (angle_m * angle_m)))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[b, 1.75e+156], N[(a * a), $MachinePrecision], N[(Pi * N[(N[(Pi * 3.08641975308642e-5), $MachinePrecision] * N[(b * N[(b * N[(angle$95$m * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.75 \cdot 10^{+156}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \left(\left(\pi \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot \left(b \cdot \left(angle\_m \cdot angle\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.7500000000000002e156Initial program 77.0%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6459.8
Applied rewrites59.8%
if 1.7500000000000002e156 < b Initial program 99.9%
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow2N/A
lower-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6474.9
lift-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval74.9
Applied rewrites74.9%
Taylor expanded in angle around 0
lower-fma.f64N/A
Applied rewrites68.1%
Taylor expanded in a around 0
Applied rewrites79.2%
Applied rewrites79.3%
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.5%
Taylor expanded in angle around 0
unpow2N/A
lower-*.f6455.9
Applied rewrites55.9%
herbie shell --seed 2024221
(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)))