Ticket #5538: family.diff

20,21c20,21
< from sage.combinat.finite_class import FiniteCombinatorialClass_l
< from sage.rings.all import ZZ
---
> from sage.combinat.finite_class import FiniteCombinatorialClass
> from sage.rings.integer import Integer
37,39c37,39
<     In its simplest form, a list l by itself is considered as the
<     family `(l[i]_{i \in I})` where `I` is the range
<     `0\dots,len(l)`. So Family(l) just returns it.
---
>     In its simplest form, a list l or a tuple by itself is considered as the
>     family `(l[i]_{i \in I})` where `I` is the range `0\dots,len(l)`. So
>     Family(l) returns the corresponding family.
45c45,48
<         [1, 2, 3]
---
>         Family (1, 2, 3)
>         sage: f = Family((1,2,3))
>         sage: f
>         Family (1, 2, 3)
87,91c90,99
<     By default, if the index set is a list, all images are computed
<     right away, and stored in an internal dictionary. Note that this
<     requires all the elements of the list to be hashable. One can ask
<     instead for the images `f(i)` to be computed lazily, when
<     needed::
---
>     By default, if the index set is a list or a tuple, all images are
>     computed right away, and stored in an internal dictionary::
> 
>         sage: f = Family((3,4,7), lambda i: 2*i)
>         sage: f
>         Finite family {3: 6, 4: 8, 7: 14}
> 
>     Note that this requires all the elements of the list to be
>     hashable. One can ask instead for the images `f(i)` to be computed
>     lazily, when needed::
121c129
<        sage: f = LazyFamily(Permutations(3), lambda i: (i.to_lehmer_code()))
---
>        sage: f = LazyFamily(Permutations(3), attrcall("to_lehmer_code"))
130,131c138,153
<     unpickle.
<     
---
>     unpickle. The following two work::
> 
>        sage: loads(dumps(LazyFamily(Permutations(3), lambda p: p.to_lehmer_code())))
>        Lazy family (f(i))_{i in Standard permutations of 3}
> 
>        sage: loads(dumps(LazyFamily(Permutations(3), attrcall("to_lehmer_code"))))
>        Lazy family (f(i))_{i in Standard permutations of 3}
> 
>     But this one dont::   
> 
>        sage: def plus_n(n): return lambda x: x+n
>        sage: loads(dumps(LazyFamily([1,2,3], plus_n(3))))
>        Traceback (most recent call last):
>        ...
>        ValueError: Cannot pickle code objects from closures
>        
249a272,293
> 
>     The factory ``Family`` is supposed to be idempotent. We test this feature here::
>     
>         sage: f = FiniteFamily({3: 'a', 4: 'b', 7: 'd'})
>         sage: g = Family(f)
>         sage: f == g
>         True
>     
>         sage: f = Family([3,4,7], lambda i: 2r*i, hidden_keys=[2])
>         sage: g = Family(f)
>         sage: f == g
>         True
> 
>         sage: f = LazyFamily([3,4,7], lambda i: 2r*i)
>         sage: g = Family(f)
>         sage: f == g
>         True
> 
>         sage: f = TrivialFamily([3,4,7])
>         sage: g = Family(f)
>         sage: f == g
>         True
252,255c296,297
<     if function == None and hidden_keys == []:
<         if type(indices) == list or isinstance(indices, FiniteCombinatorialClass_l) or isinstance(indices, FiniteFamily) or isinstance(indices, LazyFamily):
<             return indices
<         if type(indices) == dict:
---
>     if function is None and hidden_keys == []:
>         if isinstance(indices, dict):
256a299,303
>         if isinstance(indices, (list, tuple) ):
>             return TrivialFamily(indices)
>         if isinstance(indices, (FiniteCombinatorialClass,
>                                 FiniteFamily, LazyFamily, TrivialFamily) ):
>             return indices
258c305
<         if type(indices) == list or isinstance(indices, FiniteCombinatorialClass_l):
---
>         if isinstance(indices, (list, tuple, FiniteCombinatorialClass) ):
270a318,322
>     """
>     The abstract class for family
> 
>     Any family belongs to a class which inherits from ``AbstractFamily``.
>     """
360c412,420
<         """
---
> 
>         Check for bug #5538::
> 
>             sage: d = {1:"a", 3:"b", 4:"c"}
>             sage: f = Family(d)
>             sage: d[2] = 'DD'
>             sage: f
>             Finite family {1: 'a', 3: 'b', 4: 'c'}
>             """
362c422
<         self.dictionary = dictionary
---
>         self.dictionary = dict(dictionary)
409c469
<         return ZZ(len(self.dictionary))
---
>         return Integer(len(self.dictionary))
450c510
<         EXAMPLES::
---
>         TESTS::
524c584
<         EXAMPLES::
---
>         TESTS::
540c600
<         EXAMPLES::
---
>         TESTS::
549a610,617
>             
>             sage: f = LazyFamily(Permutations(3), lambda p: p.to_lehmer_code())
>             sage: f == loads(dumps(f))
>             True
> 
>             sage: f = LazyFamily(Permutations(3), attrcall("to_lehmer_code"))
>             sage: f == loads(dumps(f))
>             True
551,552c619,623
<         from sage.misc.fpickle import unpickle_function
<         hidden_function = unpickle_function(d['hidden_function'])
---
>         hidden_function = d['hidden_function']
>         if isinstance(hidden_function, str):
>         # Let's assume that hidden_function is an unpicled function.             
>             from sage.misc.fpickle import unpickle_function
>             hidden_function = unpickle_function(hidden_function)
567c638
<         EXAMPLES::
---
>         TESTS::
572a644,652
> 
>         Check for bug #5538::
>         
>             sage: l = [3,4,7]
>             sage: f = LazyFamily(l, lambda i: 2r*i);
>             sage: l[1] = 18
>             sage: f
>             Lazy family (f(i))_{i in [3, 4, 7]}
>             
574c654,655
<         self.set = set
---
>         from copy import copy
>         self.set = copy(set)
610c691
<             return ZZ(len(self.set))
---
>             return Integer(len(self.set))
649,650c730,736
<         from sage.misc.fpickle import pickle_function
<         f = pickle_function(self.function)
---
>         f = self.function
>         # This should be done once for all by registering
>         # sage.misc.fpickle.pickle_function to copy_reg
>         if type(f) is type(Family): # TODO: where is the python `function` type?
>             from sage.misc.fpickle import pickle_function
>             f = pickle_function(f)
>         
668,669c754,759
<         from sage.misc.fpickle import unpickle_function
<         function = unpickle_function(d['function'])
---
>         function = d['function']
>         if isinstance(function, str):
>         # Let's assume that function is an unpicled function.             
>             from sage.misc.fpickle import unpickle_function
>             function = unpickle_function(function)
>             
670a761,858
> 
> 
> class TrivialFamily(AbstractFamily):
>     r"""
>     ``TrivialFamily(c)`` turn the container c into a family indexed by
>     the set `{0,\dots, len(c)}`. The container `c` can be either a list or a
>     tuple.
>     
>     Instances should be created via the Family factory, which see for
>     examples and tests.
>     """
>     def __init__(self, set):
>         """
>         EXAMPLES::
>         
>             sage: f = TrivialFamily((3,4,7)); f
>             Family (3, 4, 7)
>             sage: f = TrivialFamily([3,4,7]); f
>             Family (3, 4, 7)
>             sage: f == loads(dumps(f))
>             True
>         """
>         self.set = tuple(set)
> 
>     def __repr__(self):
>         """
>         EXAMPLES::
>         
>             sage: f = TrivialFamily([3,4,7]); f
>             Family (3, 4, 7)
>         """
>         return "Family %s"%((self.set),)
> 
>     def keys(self):
>         """
>         Returns self's keys.
>         
>         EXAMPLES::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: f.keys()
>             [0, 1, 2]
>         """
>         return range(len(self.set))
> 
>     def cardinality(self):
>         """
>         Return the number of elements in self.
>         
>         EXAMPLES::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: f.cardinality()
>             3
>         """
>         return Integer(len(self.set))
>     
>     def __iter__(self):
>         """
>         EXAMPLES::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: [i for i in f]
>             [3, 4, 7]
>         """
>         for i in self.set:
>             yield i
> 
>     def __getitem__(self, i):
>         """        
>         EXAMPLES::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: f[1]
>             4        
>         """
>         return self.set[i]
> 
>     def __getstate__(self):
>         """
>         TESTS::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: f.__getstate__()
>             {'set': (3, 4, 7)}
>         """
>         return {'set': self.set}
> 
>     def __setstate__(self, state):
>         """
>         TESTS::
>         
>             sage: f = TrivialFamily([3,4,7])
>             sage: f.__setstate__({'set': (2, 4, 8)})
>             sage: f
>             Family (2, 4, 8)
>         """
>         self.__init__(state['set'])