
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* (/ angle 180.0) PI))) (+ (pow (* a (sin t_0)) 2.0) (pow (* b (cos t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * ((double) M_PI);
return pow((a * sin(t_0)), 2.0) + pow((b * cos(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * Math.PI;
return Math.pow((a * Math.sin(t_0)), 2.0) + Math.pow((b * Math.cos(t_0)), 2.0);
}
def code(a, b, angle): t_0 = (angle / 180.0) * math.pi return math.pow((a * math.sin(t_0)), 2.0) + math.pow((b * math.cos(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(Float64(angle / 180.0) * pi) return Float64((Float64(a * sin(t_0)) ^ 2.0) + (Float64(b * cos(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = (angle / 180.0) * pi; tmp = ((a * sin(t_0)) ^ 2.0) + ((b * cos(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, N[(N[Power[N[(a * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
{\left(a \cdot \sin t\_0\right)}^{2} + {\left(b \cdot \cos t\_0\right)}^{2}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* (/ angle 180.0) PI))) (+ (pow (* a (sin t_0)) 2.0) (pow (* b (cos t_0)) 2.0))))
double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * ((double) M_PI);
return pow((a * sin(t_0)), 2.0) + pow((b * cos(t_0)), 2.0);
}
public static double code(double a, double b, double angle) {
double t_0 = (angle / 180.0) * Math.PI;
return Math.pow((a * Math.sin(t_0)), 2.0) + Math.pow((b * Math.cos(t_0)), 2.0);
}
def code(a, b, angle): t_0 = (angle / 180.0) * math.pi return math.pow((a * math.sin(t_0)), 2.0) + math.pow((b * math.cos(t_0)), 2.0)
function code(a, b, angle) t_0 = Float64(Float64(angle / 180.0) * pi) return Float64((Float64(a * sin(t_0)) ^ 2.0) + (Float64(b * cos(t_0)) ^ 2.0)) end
function tmp = code(a, b, angle) t_0 = (angle / 180.0) * pi; tmp = ((a * sin(t_0)) ^ 2.0) + ((b * cos(t_0)) ^ 2.0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(angle / 180.0), $MachinePrecision] * Pi), $MachinePrecision]}, N[(N[Power[N[(a * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[(b * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{angle}{180} \cdot \pi\\
{\left(a \cdot \sin t\_0\right)}^{2} + {\left(b \cdot \cos t\_0\right)}^{2}
\end{array}
\end{array}
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= (/ angle_m 180.0) 2e-11)
(+ (* b b) (pow (* angle_m (* a (* PI 0.005555555555555556))) 2.0))
(+
(* b b)
(* (* a a) (- 0.5 (* 0.5 (cos (* (/ PI (/ 180.0 angle_m)) 2.0))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e-11) {
tmp = (b * b) + pow((angle_m * (a * (((double) M_PI) * 0.005555555555555556))), 2.0);
} else {
tmp = (b * b) + ((a * a) * (0.5 - (0.5 * cos(((((double) M_PI) / (180.0 / angle_m)) * 2.0)))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e-11) {
tmp = (b * b) + Math.pow((angle_m * (a * (Math.PI * 0.005555555555555556))), 2.0);
} else {
tmp = (b * b) + ((a * a) * (0.5 - (0.5 * Math.cos(((Math.PI / (180.0 / angle_m)) * 2.0)))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 2e-11: tmp = (b * b) + math.pow((angle_m * (a * (math.pi * 0.005555555555555556))), 2.0) else: tmp = (b * b) + ((a * a) * (0.5 - (0.5 * math.cos(((math.pi / (180.0 / angle_m)) * 2.0))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e-11) tmp = Float64(Float64(b * b) + (Float64(angle_m * Float64(a * Float64(pi * 0.005555555555555556))) ^ 2.0)); else tmp = Float64(Float64(b * b) + Float64(Float64(a * a) * Float64(0.5 - Float64(0.5 * cos(Float64(Float64(pi / Float64(180.0 / angle_m)) * 2.0)))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 2e-11) tmp = (b * b) + ((angle_m * (a * (pi * 0.005555555555555556))) ^ 2.0); else tmp = (b * b) + ((a * a) * (0.5 - (0.5 * cos(((pi / (180.0 / angle_m)) * 2.0))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e-11], N[(N[(b * b), $MachinePrecision] + N[Power[N[(angle$95$m * N[(a * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] * N[(0.5 - N[(0.5 * N[Cos[N[(N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{-11}:\\
\;\;\;\;b \cdot b + {\left(angle\_m \cdot \left(a \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + \left(a \cdot a\right) \cdot \left(0.5 - 0.5 \cdot \cos \left(\frac{\pi}{\frac{180}{angle\_m}} \cdot 2\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.99999999999999988e-11Initial program 85.1%
Taylor expanded in angle around 0
Simplified85.9%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6485.9%
Applied egg-rr85.9%
unpow2N/A
*-lowering-*.f64N/A
*-rgt-identityN/A
*-rgt-identity85.9%
Applied egg-rr85.9%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f6482.2%
Simplified82.2%
if 1.99999999999999988e-11 < (/.f64 angle #s(literal 180 binary64)) Initial program 63.0%
Taylor expanded in angle around 0
Simplified63.2%
associate-*l/N/A
+-lowering-+.f64N/A
Applied egg-rr63.6%
Final simplification77.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (pow (* (sin (/ PI (/ 180.0 angle_m))) a) 2.0) (* b b)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return pow((sin((((double) M_PI) / (180.0 / angle_m))) * a), 2.0) + (b * b);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return Math.pow((Math.sin((Math.PI / (180.0 / angle_m))) * a), 2.0) + (b * b);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return math.pow((math.sin((math.pi / (180.0 / angle_m))) * a), 2.0) + (b * b)
angle_m = abs(angle) function code(a, b, angle_m) return Float64((Float64(sin(Float64(pi / Float64(180.0 / angle_m))) * a) ^ 2.0) + Float64(b * b)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = ((sin((pi / (180.0 / angle_m))) * a) ^ 2.0) + (b * b); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[Power[N[(N[Sin[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * a), $MachinePrecision], 2.0], $MachinePrecision] + N[(b * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
{\left(\sin \left(\frac{\pi}{\frac{180}{angle\_m}}\right) \cdot a\right)}^{2} + b \cdot b
\end{array}
Initial program 79.1%
Taylor expanded in angle around 0
Simplified79.8%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6479.9%
Applied egg-rr79.9%
unpow2N/A
*-lowering-*.f64N/A
*-rgt-identityN/A
*-rgt-identity79.9%
Applied egg-rr79.9%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (+ (* b b) (pow (* a (sin (* PI (/ angle_m 180.0)))) 2.0)))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return (b * b) + pow((a * sin((((double) M_PI) * (angle_m / 180.0)))), 2.0);
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return (b * b) + Math.pow((a * Math.sin((Math.PI * (angle_m / 180.0)))), 2.0);
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return (b * b) + math.pow((a * math.sin((math.pi * (angle_m / 180.0)))), 2.0)
angle_m = abs(angle) function code(a, b, angle_m) return Float64(Float64(b * b) + (Float64(a * sin(Float64(pi * Float64(angle_m / 180.0)))) ^ 2.0)) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = (b * b) + ((a * sin((pi * (angle_m / 180.0)))) ^ 2.0); end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(N[(b * b), $MachinePrecision] + N[Power[N[(a * N[Sin[N[(Pi * N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
b \cdot b + {\left(a \cdot \sin \left(\pi \cdot \frac{angle\_m}{180}\right)\right)}^{2}
\end{array}
Initial program 79.1%
Taylor expanded in angle around 0
Simplified79.8%
*-rgt-identityN/A
pow2N/A
*-lowering-*.f6479.8%
Applied egg-rr79.8%
Final simplification79.8%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= (/ angle_m 180.0) 2e-11)
(+ (* b b) (pow (* angle_m (* a (* PI 0.005555555555555556))) 2.0))
(+
(* b b)
(* (* a a) (- 0.5 (* 0.5 (cos (* 2.0 (* PI (/ angle_m 180.0))))))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e-11) {
tmp = (b * b) + pow((angle_m * (a * (((double) M_PI) * 0.005555555555555556))), 2.0);
} else {
tmp = (b * b) + ((a * a) * (0.5 - (0.5 * cos((2.0 * (((double) M_PI) * (angle_m / 180.0)))))));
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e-11) {
tmp = (b * b) + Math.pow((angle_m * (a * (Math.PI * 0.005555555555555556))), 2.0);
} else {
tmp = (b * b) + ((a * a) * (0.5 - (0.5 * Math.cos((2.0 * (Math.PI * (angle_m / 180.0)))))));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 2e-11: tmp = (b * b) + math.pow((angle_m * (a * (math.pi * 0.005555555555555556))), 2.0) else: tmp = (b * b) + ((a * a) * (0.5 - (0.5 * math.cos((2.0 * (math.pi * (angle_m / 180.0))))))) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e-11) tmp = Float64(Float64(b * b) + (Float64(angle_m * Float64(a * Float64(pi * 0.005555555555555556))) ^ 2.0)); else tmp = Float64(Float64(b * b) + Float64(Float64(a * a) * Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * Float64(pi * Float64(angle_m / 180.0)))))))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 2e-11) tmp = (b * b) + ((angle_m * (a * (pi * 0.005555555555555556))) ^ 2.0); else tmp = (b * b) + ((a * a) * (0.5 - (0.5 * cos((2.0 * (pi * (angle_m / 180.0))))))); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e-11], N[(N[(b * b), $MachinePrecision] + N[Power[N[(angle$95$m * N[(a * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] * N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * N[(Pi * N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{-11}:\\
\;\;\;\;b \cdot b + {\left(angle\_m \cdot \left(a \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + \left(a \cdot a\right) \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \left(\pi \cdot \frac{angle\_m}{180}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.99999999999999988e-11Initial program 85.1%
Taylor expanded in angle around 0
Simplified85.9%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6485.9%
Applied egg-rr85.9%
unpow2N/A
*-lowering-*.f64N/A
*-rgt-identityN/A
*-rgt-identity85.9%
Applied egg-rr85.9%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f6482.2%
Simplified82.2%
if 1.99999999999999988e-11 < (/.f64 angle #s(literal 180 binary64)) Initial program 63.0%
Taylor expanded in angle around 0
Simplified63.2%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6463.6%
Applied egg-rr63.6%
+-lowering-+.f64N/A
Applied egg-rr63.2%
Final simplification77.1%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= a 3.4e-102) (* b b) (+ (* b b) (pow (* angle_m (* a (* PI 0.005555555555555556))) 2.0))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 3.4e-102) {
tmp = b * b;
} else {
tmp = (b * b) + pow((angle_m * (a * (((double) M_PI) * 0.005555555555555556))), 2.0);
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double tmp;
if (a <= 3.4e-102) {
tmp = b * b;
} else {
tmp = (b * b) + Math.pow((angle_m * (a * (Math.PI * 0.005555555555555556))), 2.0);
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 3.4e-102: tmp = b * b else: tmp = (b * b) + math.pow((angle_m * (a * (math.pi * 0.005555555555555556))), 2.0) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 3.4e-102) tmp = Float64(b * b); else tmp = Float64(Float64(b * b) + (Float64(angle_m * Float64(a * Float64(pi * 0.005555555555555556))) ^ 2.0)); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 3.4e-102) tmp = b * b; else tmp = (b * b) + ((angle_m * (a * (pi * 0.005555555555555556))) ^ 2.0); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 3.4e-102], N[(b * b), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[Power[N[(angle$95$m * N[(a * N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 3.4 \cdot 10^{-102}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + {\left(angle\_m \cdot \left(a \cdot \left(\pi \cdot 0.005555555555555556\right)\right)\right)}^{2}\\
\end{array}
\end{array}
if a < 3.40000000000000013e-102Initial program 79.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.3%
Simplified59.3%
if 3.40000000000000013e-102 < a Initial program 77.7%
Taylor expanded in angle around 0
Simplified78.6%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6478.7%
Applied egg-rr78.7%
unpow2N/A
*-lowering-*.f64N/A
*-rgt-identityN/A
*-rgt-identity78.7%
Applied egg-rr78.7%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f6474.2%
Simplified74.2%
Final simplification63.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(let* ((t_0
(*
(+
-0.005555555555555556
(/
(+ (* 0.005555555555555556 (* PI PI)) -0.005555555555555556)
(+ PI -1.0)))
(* angle_m a))))
(if (<= a 4e-102) (* b b) (+ (* b b) (* t_0 t_0)))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double t_0 = (-0.005555555555555556 + (((0.005555555555555556 * (((double) M_PI) * ((double) M_PI))) + -0.005555555555555556) / (((double) M_PI) + -1.0))) * (angle_m * a);
double tmp;
if (a <= 4e-102) {
tmp = b * b;
} else {
tmp = (b * b) + (t_0 * t_0);
}
return tmp;
}
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
double t_0 = (-0.005555555555555556 + (((0.005555555555555556 * (Math.PI * Math.PI)) + -0.005555555555555556) / (Math.PI + -1.0))) * (angle_m * a);
double tmp;
if (a <= 4e-102) {
tmp = b * b;
} else {
tmp = (b * b) + (t_0 * t_0);
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): t_0 = (-0.005555555555555556 + (((0.005555555555555556 * (math.pi * math.pi)) + -0.005555555555555556) / (math.pi + -1.0))) * (angle_m * a) tmp = 0 if a <= 4e-102: tmp = b * b else: tmp = (b * b) + (t_0 * t_0) return tmp
angle_m = abs(angle) function code(a, b, angle_m) t_0 = Float64(Float64(-0.005555555555555556 + Float64(Float64(Float64(0.005555555555555556 * Float64(pi * pi)) + -0.005555555555555556) / Float64(pi + -1.0))) * Float64(angle_m * a)) tmp = 0.0 if (a <= 4e-102) tmp = Float64(b * b); else tmp = Float64(Float64(b * b) + Float64(t_0 * t_0)); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) t_0 = (-0.005555555555555556 + (((0.005555555555555556 * (pi * pi)) + -0.005555555555555556) / (pi + -1.0))) * (angle_m * a); tmp = 0.0; if (a <= 4e-102) tmp = b * b; else tmp = (b * b) + (t_0 * t_0); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision]
code[a_, b_, angle$95$m_] := Block[{t$95$0 = N[(N[(-0.005555555555555556 + N[(N[(N[(0.005555555555555556 * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] + -0.005555555555555556), $MachinePrecision] / N[(Pi + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(angle$95$m * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, 4e-102], N[(b * b), $MachinePrecision], N[(N[(b * b), $MachinePrecision] + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
t_0 := \left(-0.005555555555555556 + \frac{0.005555555555555556 \cdot \left(\pi \cdot \pi\right) + -0.005555555555555556}{\pi + -1}\right) \cdot \left(angle\_m \cdot a\right)\\
\mathbf{if}\;a \leq 4 \cdot 10^{-102}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;b \cdot b + t\_0 \cdot t\_0\\
\end{array}
\end{array}
if a < 3.99999999999999973e-102Initial program 79.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.3%
Simplified59.3%
if 3.99999999999999973e-102 < a Initial program 77.7%
Taylor expanded in angle around 0
Simplified78.6%
clear-numN/A
associate-*l/N/A
*-un-lft-identityN/A
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
div-invN/A
associate-/r*N/A
metadata-evalN/A
div-invN/A
flip-+N/A
clear-numN/A
associate-*l/N/A
frac-subN/A
Applied egg-rr78.6%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
unpow2N/A
Simplified74.2%
Final simplification63.9%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= a 1.36e-102)
(* b b)
(if (<= a 4.5e+153)
(+
(* b b)
(* (* a (* a (* PI PI))) (* 3.08641975308642e-5 (* angle_m angle_m))))
(* (* angle_m (* angle_m a)) (* a (* (* PI PI) 3.08641975308642e-5))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.36e-102) {
tmp = b * b;
} else if (a <= 4.5e+153) {
tmp = (b * b) + ((a * (a * (((double) M_PI) * ((double) M_PI)))) * (3.08641975308642e-5 * (angle_m * angle_m)));
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((((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 (a <= 1.36e-102) {
tmp = b * b;
} else if (a <= 4.5e+153) {
tmp = (b * b) + ((a * (a * (Math.PI * Math.PI))) * (3.08641975308642e-5 * (angle_m * angle_m)));
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((Math.PI * Math.PI) * 3.08641975308642e-5));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 1.36e-102: tmp = b * b elif a <= 4.5e+153: tmp = (b * b) + ((a * (a * (math.pi * math.pi))) * (3.08641975308642e-5 * (angle_m * angle_m))) else: tmp = (angle_m * (angle_m * a)) * (a * ((math.pi * math.pi) * 3.08641975308642e-5)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 1.36e-102) tmp = Float64(b * b); elseif (a <= 4.5e+153) tmp = Float64(Float64(b * b) + Float64(Float64(a * Float64(a * Float64(pi * pi))) * Float64(3.08641975308642e-5 * Float64(angle_m * angle_m)))); else tmp = Float64(Float64(angle_m * Float64(angle_m * a)) * Float64(a * Float64(Float64(pi * pi) * 3.08641975308642e-5))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 1.36e-102) tmp = b * b; elseif (a <= 4.5e+153) tmp = (b * b) + ((a * (a * (pi * pi))) * (3.08641975308642e-5 * (angle_m * angle_m))); else tmp = (angle_m * (angle_m * a)) * (a * ((pi * pi) * 3.08641975308642e-5)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 1.36e-102], N[(b * b), $MachinePrecision], If[LessEqual[a, 4.5e+153], N[(N[(b * b), $MachinePrecision] + N[(N[(a * N[(a * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(3.08641975308642e-5 * N[(angle$95$m * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(angle$95$m * N[(angle$95$m * a), $MachinePrecision]), $MachinePrecision] * N[(a * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.36 \cdot 10^{-102}:\\
\;\;\;\;b \cdot b\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{+153}:\\
\;\;\;\;b \cdot b + \left(a \cdot \left(a \cdot \left(\pi \cdot \pi\right)\right)\right) \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot angle\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot \left(angle\_m \cdot a\right)\right) \cdot \left(a \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\\
\end{array}
\end{array}
if a < 1.36000000000000001e-102Initial program 79.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.3%
Simplified59.3%
if 1.36000000000000001e-102 < a < 4.5000000000000001e153Initial program 64.6%
Taylor expanded in angle around 0
Simplified66.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Simplified59.1%
if 4.5000000000000001e153 < a Initial program 99.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.8%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6499.8%
Simplified99.8%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6469.3%
Simplified69.3%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6472.7%
Applied egg-rr72.7%
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
pow2N/A
metadata-evalN/A
unpow-prod-downN/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
pow2N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6476.7%
Applied egg-rr76.7%
angle_m = (fabs.f64 angle)
(FPCore (a b angle_m)
:precision binary64
(if (<= a 1.72e-102)
(* b b)
(if (<= a 1.32e+154)
(+
(* b b)
(* (* a a) (* 3.08641975308642e-5 (* angle_m (* angle_m (* PI PI))))))
(* (* angle_m (* angle_m a)) (* a (* (* PI PI) 3.08641975308642e-5))))))angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.72e-102) {
tmp = b * b;
} else if (a <= 1.32e+154) {
tmp = (b * b) + ((a * a) * (3.08641975308642e-5 * (angle_m * (angle_m * (((double) M_PI) * ((double) M_PI))))));
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((((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 (a <= 1.72e-102) {
tmp = b * b;
} else if (a <= 1.32e+154) {
tmp = (b * b) + ((a * a) * (3.08641975308642e-5 * (angle_m * (angle_m * (Math.PI * Math.PI)))));
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((Math.PI * Math.PI) * 3.08641975308642e-5));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 1.72e-102: tmp = b * b elif a <= 1.32e+154: tmp = (b * b) + ((a * a) * (3.08641975308642e-5 * (angle_m * (angle_m * (math.pi * math.pi))))) else: tmp = (angle_m * (angle_m * a)) * (a * ((math.pi * math.pi) * 3.08641975308642e-5)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 1.72e-102) tmp = Float64(b * b); elseif (a <= 1.32e+154) tmp = Float64(Float64(b * b) + Float64(Float64(a * a) * Float64(3.08641975308642e-5 * Float64(angle_m * Float64(angle_m * Float64(pi * pi)))))); else tmp = Float64(Float64(angle_m * Float64(angle_m * a)) * Float64(a * Float64(Float64(pi * pi) * 3.08641975308642e-5))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 1.72e-102) tmp = b * b; elseif (a <= 1.32e+154) tmp = (b * b) + ((a * a) * (3.08641975308642e-5 * (angle_m * (angle_m * (pi * pi))))); else tmp = (angle_m * (angle_m * a)) * (a * ((pi * pi) * 3.08641975308642e-5)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 1.72e-102], N[(b * b), $MachinePrecision], If[LessEqual[a, 1.32e+154], N[(N[(b * b), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] * N[(3.08641975308642e-5 * N[(angle$95$m * N[(angle$95$m * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(angle$95$m * N[(angle$95$m * a), $MachinePrecision]), $MachinePrecision] * N[(a * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.72 \cdot 10^{-102}:\\
\;\;\;\;b \cdot b\\
\mathbf{elif}\;a \leq 1.32 \cdot 10^{+154}:\\
\;\;\;\;b \cdot b + \left(a \cdot a\right) \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot \left(angle\_m \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot \left(angle\_m \cdot a\right)\right) \cdot \left(a \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\\
\end{array}
\end{array}
if a < 1.72000000000000009e-102Initial program 79.8%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.3%
Simplified59.3%
if 1.72000000000000009e-102 < a < 1.31999999999999998e154Initial program 64.6%
Taylor expanded in angle around 0
Simplified66.2%
*-commutativeN/A
associate-*l/N/A
*-lowering-*.f64N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
associate-*r*N/A
sin-lowering-sin.f64N/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6466.2%
Applied egg-rr66.2%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified59.1%
if 1.31999999999999998e154 < a Initial program 99.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.8%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6499.8%
Simplified99.8%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6469.3%
Simplified69.3%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6472.7%
Applied egg-rr72.7%
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
pow2N/A
metadata-evalN/A
unpow-prod-downN/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
pow2N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6476.7%
Applied egg-rr76.7%
Final simplification61.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= a 1.9e+151) (* b b) (* (* angle_m (* angle_m a)) (* a (* (* PI PI) 3.08641975308642e-5)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.9e+151) {
tmp = b * b;
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((((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 (a <= 1.9e+151) {
tmp = b * b;
} else {
tmp = (angle_m * (angle_m * a)) * (a * ((Math.PI * Math.PI) * 3.08641975308642e-5));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 1.9e+151: tmp = b * b else: tmp = (angle_m * (angle_m * a)) * (a * ((math.pi * math.pi) * 3.08641975308642e-5)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 1.9e+151) tmp = Float64(b * b); else tmp = Float64(Float64(angle_m * Float64(angle_m * a)) * Float64(a * Float64(Float64(pi * pi) * 3.08641975308642e-5))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 1.9e+151) tmp = b * b; else tmp = (angle_m * (angle_m * a)) * (a * ((pi * pi) * 3.08641975308642e-5)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 1.9e+151], N[(b * b), $MachinePrecision], N[(N[(angle$95$m * N[(angle$95$m * a), $MachinePrecision]), $MachinePrecision] * N[(a * N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.9 \cdot 10^{+151}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot \left(angle\_m \cdot a\right)\right) \cdot \left(a \cdot \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\\
\end{array}
\end{array}
if a < 1.9e151Initial program 76.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6458.6%
Simplified58.6%
if 1.9e151 < a Initial program 99.8%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.8%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6499.8%
Simplified99.8%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6469.3%
Simplified69.3%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6472.7%
Applied egg-rr72.7%
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
pow2N/A
metadata-evalN/A
unpow-prod-downN/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
pow2N/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6476.7%
Applied egg-rr76.7%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= a 1.6e+154) (* b b) (* (* angle_m angle_m) (* a (* (* a (* PI PI)) 3.08641975308642e-5)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 1.6e+154) {
tmp = b * b;
} else {
tmp = (angle_m * angle_m) * (a * ((a * (((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 (a <= 1.6e+154) {
tmp = b * b;
} else {
tmp = (angle_m * angle_m) * (a * ((a * (Math.PI * Math.PI)) * 3.08641975308642e-5));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 1.6e+154: tmp = b * b else: tmp = (angle_m * angle_m) * (a * ((a * (math.pi * math.pi)) * 3.08641975308642e-5)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 1.6e+154) tmp = Float64(b * b); else tmp = Float64(Float64(angle_m * angle_m) * Float64(a * Float64(Float64(a * Float64(pi * pi)) * 3.08641975308642e-5))); end return tmp end
angle_m = abs(angle); function tmp_2 = code(a, b, angle_m) tmp = 0.0; if (a <= 1.6e+154) tmp = b * b; else tmp = (angle_m * angle_m) * (a * ((a * (pi * pi)) * 3.08641975308642e-5)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 1.6e+154], N[(b * b), $MachinePrecision], N[(N[(angle$95$m * angle$95$m), $MachinePrecision] * N[(a * N[(N[(a * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.6 \cdot 10^{+154}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot angle\_m\right) \cdot \left(a \cdot \left(\left(a \cdot \left(\pi \cdot \pi\right)\right) \cdot 3.08641975308642 \cdot 10^{-5}\right)\right)\\
\end{array}
\end{array}
if a < 1.6e154Initial program 76.6%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6458.8%
Simplified58.8%
if 1.6e154 < a Initial program 99.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.7%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6499.8%
Simplified99.8%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6471.8%
Simplified71.8%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f6475.2%
Applied egg-rr75.2%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (if (<= a 4e+154) (* b b) (* (* a (* a (* PI PI))) (* 3.08641975308642e-5 (* angle_m angle_m)))))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
double tmp;
if (a <= 4e+154) {
tmp = b * b;
} else {
tmp = (a * (a * (((double) M_PI) * ((double) M_PI)))) * (3.08641975308642e-5 * (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 (a <= 4e+154) {
tmp = b * b;
} else {
tmp = (a * (a * (Math.PI * Math.PI))) * (3.08641975308642e-5 * (angle_m * angle_m));
}
return tmp;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): tmp = 0 if a <= 4e+154: tmp = b * b else: tmp = (a * (a * (math.pi * math.pi))) * (3.08641975308642e-5 * (angle_m * angle_m)) return tmp
angle_m = abs(angle) function code(a, b, angle_m) tmp = 0.0 if (a <= 4e+154) tmp = Float64(b * b); else tmp = Float64(Float64(a * Float64(a * Float64(pi * pi))) * Float64(3.08641975308642e-5 * 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 (a <= 4e+154) tmp = b * b; else tmp = (a * (a * (pi * pi))) * (3.08641975308642e-5 * (angle_m * angle_m)); end tmp_2 = tmp; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := If[LessEqual[a, 4e+154], N[(b * b), $MachinePrecision], N[(N[(a * N[(a * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(3.08641975308642e-5 * N[(angle$95$m * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
angle_m = \left|angle\right|
\\
\begin{array}{l}
\mathbf{if}\;a \leq 4 \cdot 10^{+154}:\\
\;\;\;\;b \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot \left(a \cdot \left(\pi \cdot \pi\right)\right)\right) \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(angle\_m \cdot angle\_m\right)\right)\\
\end{array}
\end{array}
if a < 4.00000000000000015e154Initial program 76.6%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6458.8%
Simplified58.8%
if 4.00000000000000015e154 < a Initial program 99.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified99.7%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6499.8%
Simplified99.8%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6471.8%
Simplified71.8%
angle_m = (fabs.f64 angle) (FPCore (a b angle_m) :precision binary64 (* b b))
angle_m = fabs(angle);
double code(double a, double b, double angle_m) {
return b * b;
}
angle_m = abs(angle)
real(8) function code(a, b, angle_m)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: angle_m
code = b * b
end function
angle_m = Math.abs(angle);
public static double code(double a, double b, double angle_m) {
return b * b;
}
angle_m = math.fabs(angle) def code(a, b, angle_m): return b * b
angle_m = abs(angle) function code(a, b, angle_m) return Float64(b * b) end
angle_m = abs(angle); function tmp = code(a, b, angle_m) tmp = b * b; end
angle_m = N[Abs[angle], $MachinePrecision] code[a_, b_, angle$95$m_] := N[(b * b), $MachinePrecision]
\begin{array}{l}
angle_m = \left|angle\right|
\\
b \cdot b
\end{array}
Initial program 79.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6455.8%
Simplified55.8%
herbie shell --seed 2024160
(FPCore (a b angle)
:name "ab-angle->ABCF A"
:precision binary64
(+ (pow (* a (sin (* (/ angle 180.0) PI))) 2.0) (pow (* b (cos (* (/ angle 180.0) PI))) 2.0)))