Ticket #5891: categories-enumeratedsets-nt.patch

sage/sets/all.py

@@ -1 +1 @@
 from set import Set, is_Set, EnumeratedSet
-
+from finite_enumerated_set import FiniteEnumeratedSet
 from primes import Primes
 
 from family import Family

new file sage/sets/finite_enumerated_set.py

@@ +1 @@
+"""
+Finite Enumerated Sets
+"""
+#*****************************************************************************
+#  Copyright (C) 2009 Florent Hivert <Florent.Hivert@univ-rouen.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful, 
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.rings.integer import Integer
+
+#################################################################    
+class FiniteEnumeratedSet(UniqueRepresentation, Parent):
+    """
+    The class of finite enumerated set
+    
+    Returns the finite enumerated set with elements in ``elements`` where
+    ``element`` is any (finite) iterable object. There is no check that
+    ``elements`` does not contains twice the same value so that one can build
+    multisets.
+    
+    EXAMPLES::
+    
+        sage: S = FiniteEnumeratedSet([1, 2, 3])
+        sage: S
+        {1, 2, 3}
+        sage: S.list()
+        [1, 2, 3]
+        sage: S.cardinality()
+        3
+        sage: S.random_element()
+        1
+        sage: S.first()
+        1
+        sage: S.check()
+
+    Note that being and enumerated set, the result depend on the order::  
+        
+        sage: S1 = FiniteEnumeratedSet((1, 2, 3))
+        sage: S1
+        {1, 2, 3}        
+        sage: S1.list()
+        [1, 2, 3]
+        sage: S1 == S
+        True
+        sage: S2 = FiniteEnumeratedSet((2, 1, 3))
+        sage: S2 == S
+        False
+    """
+
+    @staticmethod
+    def __classcall__(cls, iterable):
+        """
+        TESTS::
+        
+            sage: S1 = FiniteEnumeratedSet([1, 2, 3])
+            sage: S2 = FiniteEnumeratedSet((1, 2, 3))
+            sage: S1 is S2
+            True
+        """
+        return super(FiniteEnumeratedSet, cls).__classcall__(cls, tuple(iterable))
+    
+    def __init__(self, elements):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: S == loads(dumps(S))
+            True
+        """
+        self._elements = elements
+        Parent.__init__(self, category = FiniteEnumeratedSets())
+
+    def __repr__(self):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: repr(S)
+            '{1, 2, 3}'
+        """
+        return "{"+str(self._elements)[1:-1] + '}'
+
+    def __contains__(self, x):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: 1 in S
+            True
+            sage: 2 in S
+            True
+            sage: 4 in S
+            False
+            sage: ZZ in S
+            False
+        """
+        return x in self._elements
+
+    def list(self):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: S.list()
+            [1, 2, 3]
+        """
+        return list(self._elements)
+
+    def an_element(self):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: S.an_element()
+            1
+        """
+        return self._elements[0]
+    
+    def cardinality(self):
+        """
+        TESTS::
+        
+            sage: S = FiniteEnumeratedSet([1,2,3])
+            sage: S.cardinality()
+            3
+        """        
+        return Integer(len(self._elements))
+

sage/sets/set.py

@@ -603 +602 @@
         s = repr(self.set())
         return "{" + s[5:-2] + "}"
 
+    def list(self):
+        """
+        Return the elements of self, as a list
+
+        EXAMPLES::
+        
+            sage: X = Set(GF(8,'c'))
+            sage: X
+            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}
+            sage: X.list()
+            [0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1]
+            sage: type(X.list())
+            <type 'list'>
+        """
+        # What should be the order of the result?
+        # That of self.object()? Or the order given by set(self.object())?
+        # Note: __getitem__ is currently implemented in term of this list
+        # method, which is really innefficient ...
+        return list(set(self.object()))
+
     def set(self):
         """
         Return the Python set object associated to this set.