def __classcall_private__(cls, p): r""" This function tries to recognize the input (it can be either a list or a tuple of pairs, or a fix-point free involution given as a list or as a permutation), constructs the parent (enumerated set of PerfectMatchings of the ground set) and calls the __init__ function to construct our object. EXAMPLES:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]);m [('a', 'e'), ('b', 'c'), ('d', 'f')] sage: isinstance(m,PerfectMatching) True sage: n = PerfectMatching([3, 8, 1, 7, 6, 5, 4, 2]);n [(1, 3), (2, 8), (4, 7), (5, 6)] sage: n.parent() Set of perfect matchings of {1, 2, 3, 4, 5, 6, 7, 8} sage: PerfectMatching([(1, 4), (2, 3), (5, 6)]).is_non_crossing() True The function checks that the given list or permutation is a valid perfect matching (i.e. a list of pairs with pairwise disjoint elements or a fixpoint-free involution) and raises a ValueError otherwise: sage: PerfectMatching([(1, 2, 3), (4, 5)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3), (4, 5)] is not a valid perfect matching: all elements of the list must be pairs If you know your datas are in a good format, use directly ``PerfectMatchings(objects)(data)``. TESTS:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]) sage: TestSuite(m).run() sage: m = PerfectMatching([]) sage: TestSuite(m).run() sage: PerfectMatching(6) Traceback (most recent call last): ... ValueError: cannot convert p (= 6) to a PerfectMatching sage: PerfectMatching([(1,2,3)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3)] is not a valid perfect matching: all elements of the list must be pairs sage: PerfectMatching([(1,1)]) Traceback (most recent call last): ... ValueError: [(1, 1)] is not a valid perfect matching: there are some repetitions sage: PerfectMatching(Permutation([4,2,1,3])) Traceback (most recent call last): ... ValueError: The permutation p (= [4, 2, 1, 3]) is not a fixed point free involution """ # we have to extract from the argument p the set of objects of the # matching and the list of pairs. # First case: p is a list (resp tuple) of lists (resp tuple). if (isinstance(p, list) or isinstance(p, tuple)) and ( all([isinstance(x, list) or isinstance(x, tuple) for x in p])): objects = Set(flatten(p)) data = (map(tuple, p)) #check if the data are correct if not all([len(t) == 2 for t in data]): raise ValueError("%s is not a valid perfect matching:\n" "all elements of the list must be pairs" % p) if len(objects) < 2*len(data): raise ValueError("%s is not a valid perfect matching:\n" "there are some repetitions" % p) # Second case: p is a permutation or a list of integers, we have to # check if it is a fix-point-free involution. elif ((isinstance(p, list) and all(map(lambda x: (isinstance(x, Integer) or isinstance(x, int)), p))) or isinstance(p, Permutation)): p = Permutation(p) n = len(p) if not(p.cycle_type() == [2 for i in range(n//2)]): raise ValueError("The permutation p (= %s) is not a " "fixed point free involution" % p) objects = Set(range(1, n+1)) data = p.to_cycles() # Third case: p is already a perfect matching, we return p directly elif isinstance(p, PerfectMatching): return p else: raise ValueError("cannot convert p (= %s) to a PerfectMatching" % p) # Finally, we create the parent and the element using the element # class of the parent. Note: as this function is private, when we # create an object via parent.element_class(...), __init__ is directly # executed and we do not have an infinite loop. return PerfectMatchings(objects)(data)
def __classcall_private__(cls, p): r""" This function tries to recognize the input (it can be either a list or a tuple of pairs, or a fix-point free involution given as a list or as a permutation), constructs the parent (enumerated set of PerfectMatchings of the ground set) and calls the __init__ function to construct our object. EXAMPLES:: sage: m=PerfectMatching([('a','e'),('b','c'),('d','f')]);m [('a', 'e'), ('b', 'c'), ('d', 'f')] sage: isinstance(m,PerfectMatching) True sage: n=PerfectMatching([3, 8, 1, 7, 6, 5, 4, 2]);n [(1, 3), (2, 8), (4, 7), (5, 6)] sage: n.parent() Set of perfect matchings of {1, 2, 3, 4, 5, 6, 7, 8} sage: PerfectMatching([(1, 4), (2, 3), (5, 6)]).is_non_crossing() True The function checks that the given list or permutation is a valid perfect matching (i.e. a list of pairs with pairwise disjoint elements or a fixpoint-free involution) and raises a ValueError otherwise: sage: PerfectMatching([(1, 2, 3), (4, 5)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3), (4, 5)] is not a valid perfect matching: all elements of the list must be pairs If you know your datas are in a good format, use directly ``PerfectMatchings(objects)(data)``. TESTS:: sage: m=PerfectMatching([('a','e'),('b','c'),('d','f')]) sage: TestSuite(m).run() sage: m=PerfectMatching([]) sage: TestSuite(m).run() sage: PerfectMatching(6) Traceback (most recent call last): ... ValueError: cannot convert p (= 6) to a PerfectMatching sage: PerfectMatching([(1,2,3)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3)] is not a valid perfect matching: all elements of the list must be pairs sage: PerfectMatching([(1,1)]) Traceback (most recent call last): ... ValueError: [(1, 1)] is not a valid perfect matching: there are some repetitions sage: PerfectMatching(Permutation([4,2,1,3])) Traceback (most recent call last): ... ValueError: The permutation p (= [4, 2, 1, 3]) is not a fixed point free involution """ # we have to extract from the argument p the set of objects of the # matching and the list of pairs. # First case: p is a list (resp tuple) of lists (resp tuple). if (isinstance(p, list) or isinstance(p, tuple)) and (all( [isinstance(x, list) or isinstance(x, tuple) for x in p])): objects = Set(flatten(p)) data = (map(tuple, p)) #check if the data are correct if not all([len(t) == 2 for t in data]): raise ValueError, ("%s is not a valid perfect matching:\n" "all elements of the list must be pairs" % p) if len(objects) < 2 * len(data): raise ValueError, ("%s is not a valid perfect matching:\n" "there are some repetitions" % p) # Second case: p is a permutation or a list of integers, we have to # check if it is a fix-point-free involution. elif ((isinstance(p, list) and all( map(lambda x: (isinstance(x, Integer) or isinstance(x, int)), p))) or isinstance(p, Permutation_class)): p = Permutation(p) n = len(p) if not (p.cycle_type() == [2 for i in range(n // 2)]): raise ValueError, ("The permutation p (= %s) is not a " "fixed point free involution" % p) objects = Set(range(1, n + 1)) data = p.to_cycles() # Third case: p is already a perfect matching, we return p directly elif isinstance(p, PerfectMatching): return p else: raise ValueError, "cannot convert p (= %s) to a PerfectMatching" % p # Finally, we create the parent and the element using the element # class of the parent. Note: as this function is private, when we # create an object via parent.element_class(...), __init__ is directly # executed and we do not have an infinite loop. return PerfectMatchings(objects)(data)
def __classcall_private__(cls, parts): """ Create a perfect matching from ``parts`` with the appropriate parent. This function tries to recognize the input (it can be either a list or a tuple of pairs, or a fix-point free involution given as a list or as a permutation), constructs the parent (enumerated set of PerfectMatchings of the ground set) and calls the __init__ function to construct our object. EXAMPLES:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]);m [('a', 'e'), ('b', 'c'), ('d', 'f')] sage: isinstance(m, PerfectMatching) True sage: n = PerfectMatching([3, 8, 1, 7, 6, 5, 4, 2]);n [(1, 3), (2, 8), (4, 7), (5, 6)] sage: n.parent() Perfect matchings of {1, 2, 3, 4, 5, 6, 7, 8} sage: PerfectMatching([(1, 4), (2, 3), (5, 6)]).is_noncrossing() True The function checks that the given list or permutation is a valid perfect matching (i.e. a list of pairs with pairwise disjoint elements or a fix point free involution) and raises a ``ValueError`` otherwise:: sage: PerfectMatching([(1, 2, 3), (4, 5)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3), (4, 5)] is not an element of Perfect matchings of {1, 2, 3, 4, 5} TESTS:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]) sage: TestSuite(m).run() sage: m = PerfectMatching([]) sage: TestSuite(m).run() sage: PerfectMatching(6) Traceback (most recent call last): ... TypeError: 'sage.rings.integer.Integer' object is not iterable sage: PerfectMatching([(1,2,3)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3)] is not an element of Perfect matchings of {1, 2, 3} sage: PerfectMatching([(1,1)]) Traceback (most recent call last): ... ValueError: [(1)] is not an element of Perfect matchings of {1} sage: PerfectMatching(Permutation([4,2,1,3])) Traceback (most recent call last): ... ValueError: permutation p (= [4, 2, 1, 3]) is not a fixed point free involution """ if ((isinstance(parts, list) and all( (isinstance(x, (int, Integer)) for x in parts))) or isinstance(parts, Permutation)): s = Permutation(parts) if not all(e == 2 for e in s.cycle_type()): raise ValueError("permutation p (= {}) is not a " "fixed point free involution".format(s)) parts = s.to_cycles() base_set = frozenset(e for p in parts for e in p) P = PerfectMatchings(base_set) return P(parts)
def __classcall_private__(cls, parts): """ Create a perfect matching from ``parts`` with the appropriate parent. This function tries to recognize the input (it can be either a list or a tuple of pairs, or a fix-point free involution given as a list or as a permutation), constructs the parent (enumerated set of PerfectMatchings of the ground set) and calls the __init__ function to construct our object. EXAMPLES:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]);m [('a', 'e'), ('b', 'c'), ('d', 'f')] sage: isinstance(m, PerfectMatching) True sage: n = PerfectMatching([3, 8, 1, 7, 6, 5, 4, 2]);n [(1, 3), (2, 8), (4, 7), (5, 6)] sage: n.parent() Perfect matchings of {1, 2, 3, 4, 5, 6, 7, 8} sage: PerfectMatching([(1, 4), (2, 3), (5, 6)]).is_noncrossing() True The function checks that the given list or permutation is a valid perfect matching (i.e. a list of pairs with pairwise disjoint elements or a fix point free involution) and raises a ``ValueError`` otherwise:: sage: PerfectMatching([(1, 2, 3), (4, 5)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3), (4, 5)] is not an element of Perfect matchings of {1, 2, 3, 4, 5} TESTS:: sage: m = PerfectMatching([('a','e'),('b','c'),('d','f')]) sage: TestSuite(m).run() sage: m = PerfectMatching([]) sage: TestSuite(m).run() sage: PerfectMatching(6) Traceback (most recent call last): ... TypeError: 'sage.rings.integer.Integer' object is not iterable sage: PerfectMatching([(1,2,3)]) Traceback (most recent call last): ... ValueError: [(1, 2, 3)] is not an element of Perfect matchings of {1, 2, 3} sage: PerfectMatching([(1,1)]) Traceback (most recent call last): ... ValueError: [(1)] is not an element of Perfect matchings of {1} sage: PerfectMatching(Permutation([4,2,1,3])) Traceback (most recent call last): ... ValueError: permutation p (= [4, 2, 1, 3]) is not a fixed point free involution """ if ((isinstance(parts, list) and all((isinstance(x, (int, Integer)) for x in parts))) or isinstance(parts, Permutation)): s = Permutation(parts) if not all(e == 2 for e in s.cycle_type()): raise ValueError("permutation p (= {}) is not a " "fixed point free involution".format(s)) parts = s.to_cycles() base_set = frozenset(e for p in parts for e in p) P = PerfectMatchings(base_set) return P(parts)