# Source code for ufl.constant

    """Support fpr non-literal values which are constant with respect to a domain."""

    # Copyright (C) 2019 Michal Habera
    #
    # This file is part of UFL (https://www.fenicsproject.org)
    #
    # SPDX-License-Identifier:    LGPL-3.0-or-later

    from ufl.core.terminal import Terminal
    from ufl.core.ufl_type import ufl_type
    from ufl.domain import as_domain
    from ufl.utils.counted import Counted

    @ufl_type()
    class Constant(Terminal, Counted):
        """Constant."""

        _ufl_noslots_ = True

        def __init__(self, domain, shape=(), count=None):
            """Initalise."""
            Terminal.__init__(self)
            Counted.__init__(self, count, Constant)

            self._ufl_domain = as_domain(domain)
            self._ufl_shape = shape

            # Repr string is build in such way, that reconstruction
            # with eval() is possible
            self._repr = f"Constant({self._ufl_domain!r}, {self._ufl_shape!r}, {self._count!r})"

        @property
        def ufl_shape(self):
            """Get the UFL shape."""
            return self._ufl_shape

        def ufl_domain(self):
            """Get the UFL domain."""
            return self._ufl_domain

        def ufl_domains(self):
            """Get the UFL domains."""
            return (self.ufl_domain(),)

        def is_cellwise_constant(self):
            """Return True if the function is cellwise constant."""
            return True

        def __str__(self):
            """Format as a string."""
            return f"c_{self._count}"

        def __repr__(self):
            """Representation."""
            return self._repr

        def __eq__(self, other):
            """Check equality."""
            if not isinstance(other, Constant):
                return False
            if self is other:
                return True
            return (
                self._count == other._count
                and self._ufl_domain == other._ufl_domain
                and self._ufl_shape == self._ufl_shape
            )

        def _ufl_signature_data_(self, renumbering):
            """Signature data for constant depends on renumbering."""
            return (
                f"Constant({self._ufl_domain._ufl_signature_data_(renumbering)}, "
                f"{self._ufl_shape!r}, {renumbering[self]!r})"
            )

    def VectorConstant(domain, count=None):
        """Vector constant."""
        domain = as_domain(domain)
        return Constant(domain, shape=(domain.geometric_dimension(),), count=count)

    def TensorConstant(domain, count=None):
        """Tensor constant."""
        domain = as_domain(domain)
        return Constant(
            domain, shape=(domain.geometric_dimension(), domain.geometric_dimension()), count=count
        )