The patch of 2005-05-01 made it impossible to test the type of a cl_UP

[cln.git] / src / polynomial / elem / cl_UP_gen.h

diff --git a/src/polynomial/elem/cl_UP_gen.h b/src/polynomial/elem/cl_UP_gen.h
index 6d80faa2bd0a6ff83a83c06b2d26fe891e799955..9c11643d517f154c5815747c889d5d625f891aec 100644 (file)
--- a/src/polynomial/elem/cl_UP_gen.h
+++ b/src/polynomial/elem/cl_UP_gen.h
@@ -131,6 +131,25 @@ static const _cl_UP gen_plus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const
        return _cl_UP(UPR, cl_null_SV_ringelt);
 }}
 
+static const _cl_UP gen_uminus (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
+{{
+       DeclarePoly(cl_SV_ringelt,x);
+       var cl_heap_ring* R = TheRing(UPR->basering());
+       var sintL xlen = x.length();
+       if (xlen == 0)
+               return _cl_UP(UPR, x);
+       // Now xlen > 0.
+       // Negate. No normalization necessary, since the degree doesn't change.
+       var sintL i = xlen-1;
+       var _cl_ring_element hicoeff = R->_uminus(x[i]);
+       if (R->_zerop(hicoeff)) cl_abort();
+       var cl_SV_ringelt result = cl_SV_ringelt(cl_make_heap_SV_ringelt_uninit(xlen));
+       init1(_cl_ring_element, result[i]) (hicoeff);
+       for (i-- ; i >= 0; i--)
+               init1(_cl_ring_element, result[i]) (R->_uminus(x[i]));
+       return _cl_UP(UPR, result);
+}}
+
 static const _cl_UP gen_minus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const _cl_UP& y)
 {{
        DeclarePoly(cl_SV_ringelt,x);
@@ -138,10 +157,10 @@ static const _cl_UP gen_minus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, cons
        var cl_heap_ring* R = TheRing(UPR->basering());
        var sintL xlen = x.length();
        var sintL ylen = y.length();
-       if (xlen == 0)
-               return _cl_UP(UPR, y);
        if (ylen == 0)
                return _cl_UP(UPR, x);
+       if (xlen == 0)
+               return gen_uminus(UPR,_cl_UP(UPR, y));
        // Now xlen > 0, ylen > 0.
        if (xlen > ylen) {
                var cl_SV_ringelt result = cl_SV_ringelt(cl_make_heap_SV_ringelt_uninit(xlen));
@@ -175,25 +194,6 @@ static const _cl_UP gen_minus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, cons
        return _cl_UP(UPR, cl_null_SV_ringelt);
 }}
 
-static const _cl_UP gen_uminus (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
-{{
-       DeclarePoly(cl_SV_ringelt,x);
-       var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
-       if (xlen == 0)
-               return _cl_UP(UPR, x);
-       // Now xlen > 0.
-       // Negate. No normalization necessary, since the degree doesn't change.
-       var sintL i = xlen-1;
-       var _cl_ring_element hicoeff = R->_uminus(x[i]);
-       if (R->_zerop(hicoeff)) cl_abort();
-       var cl_SV_ringelt result = cl_SV_ringelt(cl_make_heap_SV_ringelt_uninit(xlen));
-       init1(_cl_ring_element, result[i]) (hicoeff);
-       for (i-- ; i >= 0; i--)
-               init1(_cl_ring_element, result[i]) (R->_uminus(x[i]));
-       return _cl_UP(UPR, result);
-}}
-
 static const _cl_UP gen_one (cl_heap_univpoly_ring* UPR)
 {
        var cl_heap_ring* R = TheRing(UPR->basering());
@@ -337,6 +337,17 @@ static sintL gen_degree (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
        return (sintL) x.length() - 1;
 }}
 
+static sintL gen_ldegree (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
+{{     DeclarePoly(cl_SV_ringelt,x);
+       var cl_heap_ring* R = TheRing(UPR->basering());
+       var sintL xlen = x.length();
+       for (sintL i = 0; i < xlen; i++) {
+               if (!R->_zerop(x[i]))
+                       return i;
+       }
+       return -1;
+}}
+
 static const _cl_UP gen_monomial (cl_heap_univpoly_ring* UPR, const cl_ring_element& x, uintL e)
 {
        if (!(UPR->basering() == x.ring())) cl_abort();
@@ -436,6 +447,7 @@ static cl_univpoly_modulops gen_modulops = {
 
 static cl_univpoly_polyops gen_polyops = {
        gen_degree,
+       gen_ldegree,
        gen_monomial,
        gen_coeff,
        gen_create,
@@ -448,8 +460,26 @@ class cl_heap_gen_univpoly_ring : public cl_heap_univpoly_ring {
        SUBCLASS_cl_heap_univpoly_ring()
 public:
        // Constructor.
-       cl_heap_gen_univpoly_ring (const cl_ring& r)
-               : cl_heap_univpoly_ring (r, &gen_setops, &gen_addops, &gen_mulops, &gen_modulops, &gen_polyops) {}
+       cl_heap_gen_univpoly_ring (const cl_ring& r);
+       // Destructor
+       ~cl_heap_gen_univpoly_ring () {}
 };
 
+static void cl_heap_gen_univpoly_ring_destructor (cl_heap* pointer)
+{
+       (*(cl_heap_gen_univpoly_ring*)pointer).~cl_heap_gen_univpoly_ring();
+}
+
+cl_class cl_class_gen_univpoly_ring = {
+       cl_heap_gen_univpoly_ring_destructor,
+       cl_class_flags_univpoly_ring
+};
+
+// Constructor.
+inline cl_heap_gen_univpoly_ring::cl_heap_gen_univpoly_ring (const cl_ring& r)
+       : cl_heap_univpoly_ring (r, &gen_setops, &gen_addops, &gen_mulops, &gen_modulops, &gen_polyops)
+{
+       type = &cl_class_gen_univpoly_ring;
+}
+
 }  // namespace cln