Ticket #10716: trac_10716_adding_weighted_degree_v2.patch

sage/rings/polynomial/multi_polynomial_libsingular.pyx

@@ -199 +199 @@
 from sage.rings.arith import gcd
 from sage.structure.element import coerce_binop
 
+from sage.modules.free_module_element import vector
+
 from sage.structure.parent cimport Parent
 from sage.structure.parent_base cimport ParentWithBase
 from sage.structure.parent_gens cimport ParentWithGens
@@ -519 +521 @@
         Construct a new element in this polynomial ring, i.e. try to
         coerce in ``element`` if at all possible.
 
-        INPUT::
+        INPUT:
 
         - ``element`` - several types are supported, see below
         
@@ -2258 +2260 @@
         cdef ring *r = (<MPolynomialRing_libsingular>self._parent)._ring
         return singular_polynomial_deg(p,NULL,r)
 
+    def weighted_degree(self, *weights):
+        """
+        Return the weighted degree of ``self``, which is the maximum weighted
+        degree of all monomials in ``self``; the weighted degree of a monomial
+        is the sum of all powers of the variables in the monomial, each power
+        multiplied with its respective weight in ``weights''.
+
+        TODO: This implementation is slow. It should be reimplemented to use
+        the Singular interface.
+
+        INPUT:
+
+        - ``weights`` - Either individual numbers, a tuple or a dictionary,
+          specifying the weights of each variable. If it is a dictionary, it
+          maps each variable of ``self'' to its weight. If it is individual
+          numbers or a tuple, it specified the weights in the order of the
+          generators as given by ``self.parent().gens()'':
+
+        EXAMPLES::
+
+            sage: R.<x,y,z> = GF(7)[]
+            sage: p = x^3 + y + x*z^2
+            sage: p.weighted_degree({z:0, x:1, y:2})
+            3
+            sage: p.weighted_degree(1, 2, 0)
+            3
+            sage: p.weighted_degree((1, 4, 2))
+            5
+            sage: p.weighted_degree((1, 4, 1))
+            4
+            sage: q = R.random_element(100, 20) #random
+            sage: q.weighted_degree(1,1,1) == q.total_degree() 
+            True
+        """
+        # Make the weights into a vector so we can use dot_product
+        if len(weights) ==  1:
+            # First unwrap it if it is given as one element argument
+            weights = weights[0]
+
+        if isinstance(weights, tuple): 
+            weights = vector(weights)
+        elif isinstance(weights, dict):
+            weights_list = [ weights[g] for g in self.parent().gens() ]
+            weights = vector(weights_list)
+        else:
+            raise Exception('weights must be a tuple or a dictionary')
+
+        # Go through each monomial, calculating the weight by dot product
+        deg = max([ weights.dot_product(vector(m.degrees()))
+                        for m in self.monomials() ])
+        return deg
+
+
     def degrees(self):
         """ 
         Returns a tuple with the maximal degree of each variable in