Python element.Element类代码示例

    def __init__(self, core, parent):
        """
        TESTS::

            sage: C = Cores(4,3)
            sage: c = C([2,1]); c
            [2, 1]
            sage: type(c)
            <class 'sage.combinat.core.Cores_length_with_category.element_class'>
            sage: c.parent()
            4-Cores of length 3
            sage: TestSuite(c).run()

            sage: C = Cores(3,3)
            sage: C([2,1])
            Traceback (most recent call last):
            ...
            ValueError: [2, 1] is not a 3-core
        """
        k = parent.k
        part = Partition(core)
        if not part.is_core(k):
            raise ValueError, "%s is not a %s-core"%(part, k)
        CombinatorialObject.__init__(self, core)
        Element.__init__(self, parent)

    def __init__(self, poset, element, vertex):
        r"""
        Establishes the parent-child relationship between ``poset``
        and ``element``, where ``element`` is associated to the
        vertex ``vertex`` of the Hasse diagram of the poset.

        INPUT:

        - ``poset`` - a poset object

        - ``element`` - any object

        - ``vertex`` - a vertex of the Hasse diagram of the poset

        TESTS::

            sage: from sage.combinat.posets.elements import PosetElement
            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)
            sage: e = P(0)
            sage: e.parent() is P
            True
            sage: TestSuite(e).run()
        """
        Element.__init__(self, poset)
        if isinstance(element, self.parent().element_class):
            self.element = element.element
        else:
            self.element = element
        self.vertex = vertex

 def __init__(self, parent, blocks):
     self._blocks = blocks
     self._number_of_blocks = len(blocks)
     self._n = parent._n
     if not SetPartitions(self._n)(self._blocks).is_noncrossing():
         raise ValueError("{} is not noncrossing".format(blocks))
     Element.__init__(self, parent)

 def __init__(self, domain, coords=None, chart=None, name=None, 
              latex_name=None): 
     Element.__init__(self, domain)
     self.manifold = domain.manifold
     self.domain = domain
     self.coordinates = {}
     if coords is not None: 
         if len(coords) != self.manifold.dim: 
             raise ValueError("The number of coordinates must be equal" +
                              " to the manifold dimension.")
         if chart is None: 
             chart = self.domain.def_chart
         else: 
             if chart not in self.domain.atlas: 
                 raise ValueError("The " + str(chart) +
                         " has not been defined on the " + str(self.domain))
         #!# The following check is not performed for it would fail with 
         # symbolic coordinates:
         # if not chart.valid_coordinates(*coords):
         #    raise ValueError("The coordinates " + str(coords) + 
         #                     " are not valid on the " + str(chart))
         for schart in chart.supercharts:
             self.coordinates[schart] = tuple(coords) 
         for schart in chart.subcharts:
             if schart != chart:
                 if schart.valid_coordinates(*coords):
                     self.coordinates[schart] = tuple(coords)
     self.name = name
     if latex_name is None:
         self.latex_name = self.name
     else:
         self.latex_name = latex_name

    def __init__(self, model, coordinates, is_boundary, check=True, **graphics_options):
        r"""
        See ``HyperbolicPoint`` for full documentation.

        EXAMPLES::

            sage: p = HyperbolicPlane().UHP().get_point(I)
            sage: TestSuite(p).run()
        """
        if is_boundary:
            if not model.is_bounded():
                raise NotImplementedError("boundary points are not implemented in the {0} model".format(model.short_name()))
            if check and not model.boundary_point_in_model(coordinates):
                raise ValueError(
                    "{0} is not a valid".format(coordinates) +
                    " boundary point in the {0} model".format(model.short_name()))
        elif check and not model.point_in_model(coordinates):
            raise ValueError(
                "{0} is not a valid".format(coordinates) +
                " point in the {0} model".format(model.short_name()))

        if isinstance(coordinates, tuple):
            coordinates = vector(coordinates)
        self._coordinates = coordinates
        self._bdry = is_boundary
        self._graphics_options = graphics_options

        Element.__init__(self, model)

    def __init__(self, parent, Vrep, Hrep, polymake_polytope=None, **kwds):
        """
        Initializes the polyhedron.

        See :class:`Polyhedron_polymake` for a description of the input
        data.

        TESTS:

        We skip the pickling test because pickling is currently
        not implemented::

            sage: p = Polyhedron(backend='polymake')                 # optional - polymake
            sage: TestSuite(p).run(skip="_test_pickling")            # optional - polymake
            sage: p = Polyhedron(vertices=[(1, 1)], rays=[(0, 1)],   # optional - polymake
            ....:                backend='polymake')
            sage: TestSuite(p).run(skip="_test_pickling")            # optional - polymake
            sage: p = Polyhedron(vertices=[(-1,-1), (1,0), (1,1), (0,1)],  # optional - polymake
            ....:                backend='polymake')
            sage: TestSuite(p).run(skip="_test_pickling")            # optional - polymake
        """
        if polymake_polytope:
            if Hrep is not None or Vrep is not None:
                raise ValueError("only one of Vrep, Hrep, or polymake_polytope can be different from None")
            Element.__init__(self, parent=parent)
            self._init_from_polymake_polytope(polymake_polytope)
        else:
            Polyhedron_base.__init__(self, parent, Vrep, Hrep, **kwds)

    def __init__(self, parent, data):
        r"""
        TESTS::

            sage: T = TotallyOrderedFiniteSet([3,2,1],facade=False)
            sage: TestSuite(T.an_element()).run()
        """
        Element.__init__(self, parent)
        self.value = data

    def __init__(self, parent, key):
        """
        Create a cipher.

        INPUT: Parent and key

        EXAMPLES: None yet
        """
        Element.__init__(self, parent)
        self._key = key

 def __init__(self, instance, workprec=None):
     if isinstance(instance, LazyApproximationWrapper):
         raise TypeError
     Element.__init__(self, instance.parent())
     self._instance = instance
     ref = weakref.ref(self, delete_max_workprec)
     wrappers[ref] = instance
     self._ref = ref
     if workprec is not None:
         instance.update_max_workprec(workprec, wrapper=ref)

        def __init__(self, parent, m):
            r"""
            EXAMPLES::

                sage: B = crystals.elementary.Elementary(['B',7],7)
                sage: elt = B(17); elt
                17
            """
            self._m = m
            Element.__init__(self, parent)

    def __init__(self, parent, lst):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: C = Composition([3,1,2])
            sage: TestSuite(C).run()
        """
        CombinatorialObject.__init__(self, lst)
        Element.__init__(self, parent)

    def __init__(self, parent, tau):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: elt =  SimilarityClassType([[3, [3, 2, 1]], [2, [2, 1]]])
            sage: TestSuite(elt).run()
        """
        CombinatorialObject.__init__(self, sorted(tau, key=lambda PT: (PT.degree(), PT.partition())))
        Element.__init__(self, parent)

    def __init__(self, parent, vecpar):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: elt =  VectorPartition([[3, 2, 1], [2, 2, 1]])
            sage: TestSuite(elt).run()
        """
        CombinatorialObject.__init__(self, sorted(vecpar))
        Element.__init__(self, parent)

    def __init__(self, parent, x):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: mst = MultiSkewTableau([ [[None,1],[2,3]], [[1,2],[2]] ])
            sage: TestSuite(mst).run()
        """
        CombinatorialObject.__init__(self, x)
        Element.__init__(self, parent)

    def __init__(self, lst):
        """
        TESTS::

            sage: NonDecreasingParkingFunction([1, 1, 2, 2, 5, 6])
            [1, 1, 2, 2, 5, 6]
        """
        if not is_a(lst):
            raise ValueError('%s is not a non-decreasing parking function' % lst)
        parent = NonDecreasingParkingFunctions_n(len(lst))
        Element.__init__(self, parent)
        self._list = lst