
(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 17 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}
(FPCore (a b angle)
:precision binary64
(+
(* a a)
(pow
(*
b
(-
(* (sin (/ (+ 1.0 PI) (/ 180.0 angle))) (cos (/ angle 180.0)))
(* (cos (/ (* (+ 1.0 PI) angle) 180.0)) (sin (/ angle 180.0)))))
2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * ((sin(((1.0 + ((double) M_PI)) / (180.0 / angle))) * cos((angle / 180.0))) - (cos((((1.0 + ((double) M_PI)) * angle) / 180.0)) * sin((angle / 180.0))))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * ((Math.sin(((1.0 + Math.PI) / (180.0 / angle))) * Math.cos((angle / 180.0))) - (Math.cos((((1.0 + Math.PI) * angle) / 180.0)) * Math.sin((angle / 180.0))))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * ((math.sin(((1.0 + math.pi) / (180.0 / angle))) * math.cos((angle / 180.0))) - (math.cos((((1.0 + math.pi) * angle) / 180.0)) * math.sin((angle / 180.0))))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * Float64(Float64(sin(Float64(Float64(1.0 + pi) / Float64(180.0 / angle))) * cos(Float64(angle / 180.0))) - Float64(cos(Float64(Float64(Float64(1.0 + pi) * angle) / 180.0)) * sin(Float64(angle / 180.0))))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * ((sin(((1.0 + pi) / (180.0 / angle))) * cos((angle / 180.0))) - (cos((((1.0 + pi) * angle) / 180.0)) * sin((angle / 180.0))))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[(N[(N[Sin[N[(N[(1.0 + Pi), $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(angle / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[N[(N[(N[(1.0 + Pi), $MachinePrecision] * angle), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(angle / 180.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \left(\sin \left(\frac{1 + \pi}{\frac{180}{angle}}\right) \cdot \cos \left(\frac{angle}{180}\right) - \cos \left(\frac{\left(1 + \pi\right) \cdot angle}{180}\right) \cdot \sin \left(\frac{angle}{180}\right)\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
associate-*l/N/A
associate-/r/N/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6479.1%
Applied egg-rr79.1%
sin-diffN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr79.1%
cos-lowering-cos.f64N/A
associate-/r/N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f6479.2%
Applied egg-rr79.2%
(FPCore (a b angle) :precision binary64 (+ (* a a) (pow (* b (sin (- (/ (+ 1.0 PI) (/ 180.0 angle)) (/ angle 180.0)))) 2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin((((1.0 + ((double) M_PI)) / (180.0 / angle)) - (angle / 180.0)))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin((((1.0 + Math.PI) / (180.0 / angle)) - (angle / 180.0)))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin((((1.0 + math.pi) / (180.0 / angle)) - (angle / 180.0)))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(Float64(Float64(1.0 + pi) / Float64(180.0 / angle)) - Float64(angle / 180.0)))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin((((1.0 + pi) / (180.0 / angle)) - (angle / 180.0)))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(N[(N[(1.0 + Pi), $MachinePrecision] / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision] - N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(\frac{1 + \pi}{\frac{180}{angle}} - \frac{angle}{180}\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
associate-*l/N/A
associate-/r/N/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6479.1%
Applied egg-rr79.1%
(FPCore (a b angle)
:precision binary64
(+
(* a a)
(pow
(*
b
(sin (- (* (* (+ 1.0 PI) angle) 0.005555555555555556) (/ angle 180.0))))
2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin(((((1.0 + ((double) M_PI)) * angle) * 0.005555555555555556) - (angle / 180.0)))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin(((((1.0 + Math.PI) * angle) * 0.005555555555555556) - (angle / 180.0)))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin(((((1.0 + math.pi) * angle) * 0.005555555555555556) - (angle / 180.0)))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(Float64(Float64(Float64(1.0 + pi) * angle) * 0.005555555555555556) - Float64(angle / 180.0)))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin(((((1.0 + pi) * angle) * 0.005555555555555556) - (angle / 180.0)))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(N[(N[(N[(1.0 + Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.005555555555555556), $MachinePrecision] - N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(\left(\left(1 + \pi\right) \cdot angle\right) \cdot 0.005555555555555556 - \frac{angle}{180}\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
associate-*l/N/A
associate-/r/N/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6479.1%
Applied egg-rr79.1%
div-invN/A
clear-numN/A
div-invN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
metadata-eval79.1%
Applied egg-rr79.1%
(FPCore (a b angle) :precision binary64 (+ (* a a) (pow (* b (sin (/ 1.0 (/ (/ 180.0 angle) PI)))) 2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin((1.0 / ((180.0 / angle) / ((double) M_PI))))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin((1.0 / ((180.0 / angle) / Math.PI)))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin((1.0 / ((180.0 / angle) / math.pi)))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(1.0 / Float64(Float64(180.0 / angle) / pi)))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin((1.0 / ((180.0 / angle) / pi)))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(1.0 / N[(N[(180.0 / angle), $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(\frac{1}{\frac{\frac{180}{angle}}{\pi}}\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
associate-*l/N/A
associate-/r/N/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6479.1%
Applied egg-rr79.1%
clear-numN/A
sub-divN/A
rem-exp-logN/A
log1p-undefineN/A
expm1-undefineN/A
expm1-log1p-uN/A
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f6479.1%
Applied egg-rr79.1%
(FPCore (a b angle) :precision binary64 (+ (* a a) (pow (* b (sin (/ 1.0 (/ 180.0 (* PI angle))))) 2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin((1.0 / (180.0 / (((double) M_PI) * angle))))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin((1.0 / (180.0 / (Math.PI * angle))))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin((1.0 / (180.0 / (math.pi * angle))))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(1.0 / Float64(180.0 / Float64(pi * angle))))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin((1.0 / (180.0 / (pi * angle))))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(1.0 / N[(180.0 / N[(Pi * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(\frac{1}{\frac{180}{\pi \cdot angle}}\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
associate-*l/N/A
associate-/r/N/A
clear-numN/A
/-lowering-/.f64N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6479.1%
Applied egg-rr79.1%
(FPCore (a b angle) :precision binary64 (+ (* a a) (pow (* b (sin (* 0.005555555555555556 (* PI angle)))) 2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin((0.005555555555555556 * (((double) M_PI) * angle)))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin((0.005555555555555556 * (Math.PI * angle)))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin((0.005555555555555556 * (math.pi * angle)))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(0.005555555555555556 * Float64(pi * angle)))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin((0.005555555555555556 * (pi * angle)))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)}^{2}
\end{array}
Initial program 78.7%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
div-invN/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6479.0%
Applied egg-rr79.0%
Final simplification79.0%
(FPCore (a b angle) :precision binary64 (+ (* a a) (pow (* b (sin (* PI (/ angle 180.0)))) 2.0)))
double code(double a, double b, double angle) {
return (a * a) + pow((b * sin((((double) M_PI) * (angle / 180.0)))), 2.0);
}
public static double code(double a, double b, double angle) {
return (a * a) + Math.pow((b * Math.sin((Math.PI * (angle / 180.0)))), 2.0);
}
def code(a, b, angle): return (a * a) + math.pow((b * math.sin((math.pi * (angle / 180.0)))), 2.0)
function code(a, b, angle) return Float64(Float64(a * a) + (Float64(b * sin(Float64(pi * Float64(angle / 180.0)))) ^ 2.0)) end
function tmp = code(a, b, angle) tmp = (a * a) + ((b * sin((pi * (angle / 180.0)))) ^ 2.0); end
code[a_, b_, angle_] := N[(N[(a * a), $MachinePrecision] + N[Power[N[(b * N[Sin[N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a + {\left(b \cdot \sin \left(\pi \cdot \frac{angle}{180}\right)\right)}^{2}
\end{array}
Initial program 78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6479.0%
Simplified79.0%
(FPCore (a b angle)
:precision binary64
(if (<= (/ angle 180.0) 4e-16)
(+
(* a a)
(pow
(*
angle
(*
b
(*
PI
(+
0.005555555555555556
(* (* (* angle angle) -2.8577960676726107e-8) (* PI PI))))))
2.0))
(+
(* a a)
(* b (* b (- 0.5 (* 0.5 (cos (* 2.0 (/ PI (/ 180.0 angle)))))))))))
double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + pow((angle * (b * (((double) M_PI) * (0.005555555555555556 + (((angle * angle) * -2.8577960676726107e-8) * (((double) M_PI) * ((double) M_PI))))))), 2.0);
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (((double) M_PI) / (180.0 / angle))))))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + Math.pow((angle * (b * (Math.PI * (0.005555555555555556 + (((angle * angle) * -2.8577960676726107e-8) * (Math.PI * Math.PI)))))), 2.0);
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * Math.cos((2.0 * (Math.PI / (180.0 / angle))))))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if (angle / 180.0) <= 4e-16: tmp = (a * a) + math.pow((angle * (b * (math.pi * (0.005555555555555556 + (((angle * angle) * -2.8577960676726107e-8) * (math.pi * math.pi)))))), 2.0) else: tmp = (a * a) + (b * (b * (0.5 - (0.5 * math.cos((2.0 * (math.pi / (180.0 / angle)))))))) return tmp
function code(a, b, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 4e-16) tmp = Float64(Float64(a * a) + (Float64(angle * Float64(b * Float64(pi * Float64(0.005555555555555556 + Float64(Float64(Float64(angle * angle) * -2.8577960676726107e-8) * Float64(pi * pi)))))) ^ 2.0)); else tmp = Float64(Float64(a * a) + Float64(b * Float64(b * Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * Float64(pi / Float64(180.0 / angle))))))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((angle / 180.0) <= 4e-16) tmp = (a * a) + ((angle * (b * (pi * (0.005555555555555556 + (((angle * angle) * -2.8577960676726107e-8) * (pi * pi)))))) ^ 2.0); else tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (pi / (180.0 / angle)))))))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 4e-16], N[(N[(a * a), $MachinePrecision] + N[Power[N[(angle * N[(b * N[(Pi * N[(0.005555555555555556 + N[(N[(N[(angle * angle), $MachinePrecision] * -2.8577960676726107e-8), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(b * N[(b * N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 4 \cdot 10^{-16}:\\
\;\;\;\;a \cdot a + {\left(angle \cdot \left(b \cdot \left(\pi \cdot \left(0.005555555555555556 + \left(\left(angle \cdot angle\right) \cdot -2.8577960676726107 \cdot 10^{-8}\right) \cdot \left(\pi \cdot \pi\right)\right)\right)\right)\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + b \cdot \left(b \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \frac{\pi}{\frac{180}{angle}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 3.9999999999999999e-16Initial program 83.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified84.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6484.1%
Simplified84.1%
Taylor expanded in angle around 0
distribute-lft-inN/A
fma-defineN/A
*-commutativeN/A
associate-*r*N/A
fma-undefineN/A
distribute-lft-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
Simplified78.9%
if 3.9999999999999999e-16 < (/.f64 angle #s(literal 180 binary64)) Initial program 59.4%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified59.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6460.2%
Simplified60.2%
unpow2N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr60.3%
associate-*r*N/A
pow2N/A
associate-/r/N/A
associate-*l/N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr60.3%
Final simplification74.9%
(FPCore (a b angle)
:precision binary64
(if (<= (/ angle 180.0) 4e-16)
(+
(* a a)
(* (* b angle) (* (* (* PI PI) 3.08641975308642e-5) (* b angle))))
(+
(* a a)
(* b (* b (- 0.5 (* 0.5 (cos (* 2.0 (/ PI (/ 180.0 angle)))))))))))
double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + ((b * angle) * (((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * (b * angle)));
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (((double) M_PI) / (180.0 / angle))))))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + ((b * angle) * (((Math.PI * Math.PI) * 3.08641975308642e-5) * (b * angle)));
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * Math.cos((2.0 * (Math.PI / (180.0 / angle))))))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if (angle / 180.0) <= 4e-16: tmp = (a * a) + ((b * angle) * (((math.pi * math.pi) * 3.08641975308642e-5) * (b * angle))) else: tmp = (a * a) + (b * (b * (0.5 - (0.5 * math.cos((2.0 * (math.pi / (180.0 / angle)))))))) return tmp
function code(a, b, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 4e-16) tmp = Float64(Float64(a * a) + Float64(Float64(b * angle) * Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(b * angle)))); else tmp = Float64(Float64(a * a) + Float64(b * Float64(b * Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * Float64(pi / Float64(180.0 / angle))))))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((angle / 180.0) <= 4e-16) tmp = (a * a) + ((b * angle) * (((pi * pi) * 3.08641975308642e-5) * (b * angle))); else tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (pi / (180.0 / angle)))))))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 4e-16], N[(N[(a * a), $MachinePrecision] + N[(N[(b * angle), $MachinePrecision] * N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(b * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(b * N[(b * N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 4 \cdot 10^{-16}:\\
\;\;\;\;a \cdot a + \left(b \cdot angle\right) \cdot \left(\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot angle\right)\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + b \cdot \left(b \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \frac{\pi}{\frac{180}{angle}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 3.9999999999999999e-16Initial program 83.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified84.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6484.1%
Simplified84.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified63.5%
*-commutativeN/A
unswap-sqrN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6480.5%
Applied egg-rr80.5%
if 3.9999999999999999e-16 < (/.f64 angle #s(literal 180 binary64)) Initial program 59.4%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified59.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6460.2%
Simplified60.2%
unpow2N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr60.3%
associate-*r*N/A
pow2N/A
associate-/r/N/A
associate-*l/N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr60.3%
Final simplification76.2%
(FPCore (a b angle)
:precision binary64
(if (<= (/ angle 180.0) 4e-16)
(+
(* a a)
(* (* b angle) (* (* (* PI PI) 3.08641975308642e-5) (* b angle))))
(+
(* a a)
(* b (* b (- 0.5 (* 0.5 (cos (* 2.0 (* PI (/ angle 180.0)))))))))))
double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + ((b * angle) * (((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * (b * angle)));
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (((double) M_PI) * (angle / 180.0))))))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e-16) {
tmp = (a * a) + ((b * angle) * (((Math.PI * Math.PI) * 3.08641975308642e-5) * (b * angle)));
} else {
tmp = (a * a) + (b * (b * (0.5 - (0.5 * Math.cos((2.0 * (Math.PI * (angle / 180.0))))))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if (angle / 180.0) <= 4e-16: tmp = (a * a) + ((b * angle) * (((math.pi * math.pi) * 3.08641975308642e-5) * (b * angle))) else: tmp = (a * a) + (b * (b * (0.5 - (0.5 * math.cos((2.0 * (math.pi * (angle / 180.0)))))))) return tmp
function code(a, b, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 4e-16) tmp = Float64(Float64(a * a) + Float64(Float64(b * angle) * Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(b * angle)))); else tmp = Float64(Float64(a * a) + Float64(b * Float64(b * Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * Float64(pi * Float64(angle / 180.0))))))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((angle / 180.0) <= 4e-16) tmp = (a * a) + ((b * angle) * (((pi * pi) * 3.08641975308642e-5) * (b * angle))); else tmp = (a * a) + (b * (b * (0.5 - (0.5 * cos((2.0 * (pi * (angle / 180.0)))))))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 4e-16], N[(N[(a * a), $MachinePrecision] + N[(N[(b * angle), $MachinePrecision] * N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(b * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(b * N[(b * N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 4 \cdot 10^{-16}:\\
\;\;\;\;a \cdot a + \left(b \cdot angle\right) \cdot \left(\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot angle\right)\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + b \cdot \left(b \cdot \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \left(\pi \cdot \frac{angle}{180}\right)\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 3.9999999999999999e-16Initial program 83.9%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified84.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6484.1%
Simplified84.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified63.5%
*-commutativeN/A
unswap-sqrN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6480.5%
Applied egg-rr80.5%
if 3.9999999999999999e-16 < (/.f64 angle #s(literal 180 binary64)) Initial program 59.4%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified59.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6460.2%
Simplified60.2%
associate-*l/N/A
associate-/r/N/A
expm1-log1p-uN/A
expm1-undefineN/A
div-subN/A
clear-numN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
log1p-undefineN/A
rem-exp-logN/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6460.6%
Applied egg-rr60.6%
sin-diffN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr60.6%
unpow-prod-downN/A
pow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
Applied egg-rr60.1%
Final simplification76.2%
(FPCore (a b angle)
:precision binary64
(if (<= b 2.2e-80)
(* a a)
(+
(* a a)
(* (* b angle) (* (* (* PI PI) 3.08641975308642e-5) (* b angle))))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 2.2e-80) {
tmp = a * a;
} else {
tmp = (a * a) + ((b * angle) * (((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * (b * angle)));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 2.2e-80) {
tmp = a * a;
} else {
tmp = (a * a) + ((b * angle) * (((Math.PI * Math.PI) * 3.08641975308642e-5) * (b * angle)));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 2.2e-80: tmp = a * a else: tmp = (a * a) + ((b * angle) * (((math.pi * math.pi) * 3.08641975308642e-5) * (b * angle))) return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 2.2e-80) tmp = Float64(a * a); else tmp = Float64(Float64(a * a) + Float64(Float64(b * angle) * Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(b * angle)))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 2.2e-80) tmp = a * a; else tmp = (a * a) + ((b * angle) * (((pi * pi) * 3.08641975308642e-5) * (b * angle))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 2.2e-80], N[(a * a), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(N[(b * angle), $MachinePrecision] * N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(b * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.2 \cdot 10^{-80}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + \left(b \cdot angle\right) \cdot \left(\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot angle\right)\right)\\
\end{array}
\end{array}
if b < 2.2000000000000001e-80Initial program 77.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.2%
Simplified59.2%
if 2.2000000000000001e-80 < b Initial program 82.3%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified82.3%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6481.6%
Simplified81.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
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified54.8%
*-commutativeN/A
unswap-sqrN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6476.9%
Applied egg-rr76.9%
Final simplification63.4%
(FPCore (a b angle)
:precision binary64
(if (<= b 1.35e-82)
(* a a)
(+
(* a a)
(* (* (* PI PI) 3.08641975308642e-5) (* b (* angle (* b angle)))))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 1.35e-82) {
tmp = a * a;
} else {
tmp = (a * a) + (((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * (b * (angle * (b * angle))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 1.35e-82) {
tmp = a * a;
} else {
tmp = (a * a) + (((Math.PI * Math.PI) * 3.08641975308642e-5) * (b * (angle * (b * angle))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 1.35e-82: tmp = a * a else: tmp = (a * a) + (((math.pi * math.pi) * 3.08641975308642e-5) * (b * (angle * (b * angle)))) return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 1.35e-82) tmp = Float64(a * a); else tmp = Float64(Float64(a * a) + Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(b * Float64(angle * Float64(b * angle))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 1.35e-82) tmp = a * a; else tmp = (a * a) + (((pi * pi) * 3.08641975308642e-5) * (b * (angle * (b * angle)))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 1.35e-82], N[(a * a), $MachinePrecision], N[(N[(a * a), $MachinePrecision] + N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(b * N[(angle * N[(b * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.35 \cdot 10^{-82}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;a \cdot a + \left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot \left(angle \cdot \left(b \cdot angle\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.3500000000000001e-82Initial program 77.5%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6459.2%
Simplified59.2%
if 1.3500000000000001e-82 < b Initial program 82.3%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified82.3%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6481.6%
Simplified81.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
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified54.8%
unswap-sqrN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.3%
Applied egg-rr74.3%
Final simplification62.8%
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* b (* PI (/ angle 180.0))))) (if (<= b 1.9e+129) (* a a) (* t_0 t_0))))
double code(double a, double b, double angle) {
double t_0 = b * (((double) M_PI) * (angle / 180.0));
double tmp;
if (b <= 1.9e+129) {
tmp = a * a;
} else {
tmp = t_0 * t_0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = b * (Math.PI * (angle / 180.0));
double tmp;
if (b <= 1.9e+129) {
tmp = a * a;
} else {
tmp = t_0 * t_0;
}
return tmp;
}
def code(a, b, angle): t_0 = b * (math.pi * (angle / 180.0)) tmp = 0 if b <= 1.9e+129: tmp = a * a else: tmp = t_0 * t_0 return tmp
function code(a, b, angle) t_0 = Float64(b * Float64(pi * Float64(angle / 180.0))) tmp = 0.0 if (b <= 1.9e+129) tmp = Float64(a * a); else tmp = Float64(t_0 * t_0); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = b * (pi * (angle / 180.0)); tmp = 0.0; if (b <= 1.9e+129) tmp = a * a; else tmp = t_0 * t_0; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(b * N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, 1.9e+129], N[(a * a), $MachinePrecision], N[(t$95$0 * t$95$0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := b \cdot \left(\pi \cdot \frac{angle}{180}\right)\\
\mathbf{if}\;b \leq 1.9 \cdot 10^{+129}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot t\_0\\
\end{array}
\end{array}
if b < 1.90000000000000003e129Initial program 76.0%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6457.5%
Simplified57.5%
if 1.90000000000000003e129 < b Initial program 95.2%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified95.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6495.1%
Simplified95.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified59.8%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6454.3%
Simplified54.3%
metadata-evalN/A
associate-*r*N/A
pow2N/A
pow2N/A
pow-prod-downN/A
*-commutativeN/A
unpow-prod-downN/A
unpow2N/A
swap-sqrN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
div-invN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
Applied egg-rr81.2%
(FPCore (a b angle) :precision binary64 (if (<= b 1.9e+147) (* a a) (* (* (* PI PI) 3.08641975308642e-5) (* b (* b (* angle angle))))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 1.9e+147) {
tmp = a * a;
} else {
tmp = ((((double) M_PI) * ((double) M_PI)) * 3.08641975308642e-5) * (b * (b * (angle * angle)));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 1.9e+147) {
tmp = a * a;
} else {
tmp = ((Math.PI * Math.PI) * 3.08641975308642e-5) * (b * (b * (angle * angle)));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 1.9e+147: tmp = a * a else: tmp = ((math.pi * math.pi) * 3.08641975308642e-5) * (b * (b * (angle * angle))) return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 1.9e+147) tmp = Float64(a * a); else tmp = Float64(Float64(Float64(pi * pi) * 3.08641975308642e-5) * Float64(b * Float64(b * Float64(angle * angle)))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 1.9e+147) tmp = a * a; else tmp = ((pi * pi) * 3.08641975308642e-5) * (b * (b * (angle * angle))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 1.9e+147], N[(a * a), $MachinePrecision], N[(N[(N[(Pi * Pi), $MachinePrecision] * 3.08641975308642e-5), $MachinePrecision] * N[(b * N[(b * N[(angle * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.9 \cdot 10^{+147}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\pi \cdot \pi\right) \cdot 3.08641975308642 \cdot 10^{-5}\right) \cdot \left(b \cdot \left(b \cdot \left(angle \cdot angle\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.89999999999999985e147Initial program 76.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6457.2%
Simplified57.2%
if 1.89999999999999985e147 < b Initial program 97.1%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified97.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6497.1%
Simplified97.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified59.4%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6459.4%
Simplified59.4%
Taylor expanded in b around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/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.f6475.0%
Simplified75.0%
Final simplification59.3%
(FPCore (a b angle) :precision binary64 (if (<= b 1.25e+148) (* a a) (* b (* b (* PI (* 3.08641975308642e-5 (* PI (* angle angle))))))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 1.25e+148) {
tmp = a * a;
} else {
tmp = b * (b * (((double) M_PI) * (3.08641975308642e-5 * (((double) M_PI) * (angle * angle)))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 1.25e+148) {
tmp = a * a;
} else {
tmp = b * (b * (Math.PI * (3.08641975308642e-5 * (Math.PI * (angle * angle)))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 1.25e+148: tmp = a * a else: tmp = b * (b * (math.pi * (3.08641975308642e-5 * (math.pi * (angle * angle))))) return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 1.25e+148) tmp = Float64(a * a); else tmp = Float64(b * Float64(b * Float64(pi * Float64(3.08641975308642e-5 * Float64(pi * Float64(angle * angle)))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 1.25e+148) tmp = a * a; else tmp = b * (b * (pi * (3.08641975308642e-5 * (pi * (angle * angle))))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 1.25e+148], N[(a * a), $MachinePrecision], N[(b * N[(b * N[(Pi * N[(3.08641975308642e-5 * N[(Pi * N[(angle * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.25 \cdot 10^{+148}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(b \cdot \left(\pi \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(\pi \cdot \left(angle \cdot angle\right)\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.25000000000000006e148Initial program 76.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6457.2%
Simplified57.2%
if 1.25000000000000006e148 < b Initial program 97.1%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified97.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6497.1%
Simplified97.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified59.4%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6459.4%
Simplified59.4%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr75.0%
Final simplification59.3%
(FPCore (a b angle) :precision binary64 (if (<= b 1.5e+148) (* a a) (* (* b b) (* 3.08641975308642e-5 (* PI (* PI (* angle angle)))))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 1.5e+148) {
tmp = a * a;
} else {
tmp = (b * b) * (3.08641975308642e-5 * (((double) M_PI) * (((double) M_PI) * (angle * angle))));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 1.5e+148) {
tmp = a * a;
} else {
tmp = (b * b) * (3.08641975308642e-5 * (Math.PI * (Math.PI * (angle * angle))));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 1.5e+148: tmp = a * a else: tmp = (b * b) * (3.08641975308642e-5 * (math.pi * (math.pi * (angle * angle)))) return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 1.5e+148) tmp = Float64(a * a); else tmp = Float64(Float64(b * b) * Float64(3.08641975308642e-5 * Float64(pi * Float64(pi * Float64(angle * angle))))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 1.5e+148) tmp = a * a; else tmp = (b * b) * (3.08641975308642e-5 * (pi * (pi * (angle * angle)))); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 1.5e+148], N[(a * a), $MachinePrecision], N[(N[(b * b), $MachinePrecision] * N[(3.08641975308642e-5 * N[(Pi * N[(Pi * N[(angle * angle), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.5 \cdot 10^{+148}:\\
\;\;\;\;a \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot b\right) \cdot \left(3.08641975308642 \cdot 10^{-5} \cdot \left(\pi \cdot \left(\pi \cdot \left(angle \cdot angle\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.50000000000000007e148Initial program 76.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6457.2%
Simplified57.2%
if 1.50000000000000007e148 < b Initial program 97.1%
+-lowering-+.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
pow-lowering-pow.f64N/A
Simplified97.1%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6497.1%
Simplified97.1%
Taylor expanded in angle around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified59.4%
Taylor expanded in a around 0
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6459.4%
Simplified59.4%
(FPCore (a b angle) :precision binary64 (* a a))
double code(double a, double b, double angle) {
return a * a;
}
real(8) function code(a, b, angle)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: angle
code = a * a
end function
public static double code(double a, double b, double angle) {
return a * a;
}
def code(a, b, angle): return a * a
function code(a, b, angle) return Float64(a * a) end
function tmp = code(a, b, angle) tmp = a * a; end
code[a_, b_, angle_] := N[(a * a), $MachinePrecision]
\begin{array}{l}
\\
a \cdot a
\end{array}
Initial program 78.7%
Taylor expanded in angle around 0
unpow2N/A
*-lowering-*.f6453.2%
Simplified53.2%
herbie shell --seed 2024147
(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)))