r"""
The Real Line and Open Intervals

The class :class:`OpenInterval` implement open intervals as 1-dimensional
differentiable manifolds over `\RR`. The derived class :class:`RealLine` is
devoted to `\RR` itself, as the open interval `(-\infty, +\infty)`.

AUTHORS:

- Eric Gourgoulhon (2015): initial version
- Travis Scrimshaw (2016): review tweaks

REFERENCES:

- [Lee2013]_

"""
#*****************************************************************************
#       Copyright (C) 2015 Eric Gourgoulhon <eric.gourgoulhon@obspm.fr>
#       Copyright (C) 2015 Michal Bejger <bejger@camk.edu.pl>
#
#  Distributed under the terms of the GNU General Public License (GPL)
#  as published by the Free Software Foundation; either version 2 of
#  the License, or (at your option) any later version.
#                  http://www.gnu.org/licenses/
#*****************************************************************************

from sage.misc.latex import latex
from sage.rings.infinity import infinity, minus_infinity
from sage.symbolic.ring import SR
from sage.manifolds.differentiable.manifold import DifferentiableManifold
from sage.manifolds.structure import RealDifferentialStructure

class OpenInterval(DifferentiableManifold):
    r"""
    Open interval as a 1-dimensional differentiable manifold over `\RR`.

    INPUT:

    - ``lower`` -- lower bound of the interval (possibly ``-Infinity``)
    - ``upper`` -- upper bound of the interval (possibly ``+Infinity``)
    - ``ambient_interval`` -- (default: ``None``) another open interval,
      to which the constructed interval is a subset of
    - ``name`` -- (default: ``None``) string; name (symbol) given to
      the interval; if ``None``, the name is constructed from ``lower``
      and ``upper``
    - ``latex_name`` -- (default: ``None``) string; LaTeX symbol to denote the
      interval; if ``None``, the LaTeX symbol is constructed from ``lower``
      and ``upper`` if ``name`` is ``None``, otherwise, it is set to ``name``
    - ``coordinate`` -- (default: ``None``) string defining the symbol of the
      canonical coordinate set on the interval; if none is provided and
      ``names`` is ``None``, the symbol 't' is used
    - ``names`` -- (default: ``None``) used only when ``coordinate`` is
      ``None``: it must be a single-element tuple containing the canonical
      coordinate symbol (this is guaranteed if the shortcut ``<names>`` is
      used, see examples below)
    - ``start_index`` -- (default: 0) unique value of the index for vectors
      and forms on the interval manifold

    EXAMPLES:

    The interval `(0,\pi)`::

        sage: I = OpenInterval(0, pi); I
        Real interval (0, pi)
        sage: latex(I)
        \left(0, \pi\right)

    ``I`` is a 1-dimensional smooth manifold over `\RR`::

        sage: I.category()
        Category of smooth manifolds over Real Field with 53 bits of precision
        sage: I.base_field()
        Real Field with 53 bits of precision
        sage: dim(I)
        1

    It is infinitely differentiable (smooth manifold)::

        sage: I.diff_degree()
        +Infinity

    The instance is unique (as long as the constructor arguments
    are the same)::

        sage: I is OpenInterval(0, pi)
        True
        sage: I is OpenInterval(0, pi, name='I')
        False

    The display of the interval can be customized::

        sage: I  # default display
        Real interval (0, pi)
        sage: latex(I)  # default LaTeX display
        \left(0, \pi\right)
        sage: I1 = OpenInterval(0, pi, name='I'); I1
        Real interval I
        sage: latex(I1)
        I
        sage: I2 = OpenInterval(0, pi, name='I', latex_name=r'\mathcal{I}'); I2
        Real interval I
        sage: latex(I2)
        \mathcal{I}

    ``I`` is endowed with a canonical chart::

        sage: I.canonical_chart()
        Chart ((0, pi), (t,))
        sage: I.canonical_chart() is I.default_chart()
        True
        sage: I.atlas()
        [Chart ((0, pi), (t,))]

    The canonical coordinate is returned by the method
    :meth:`canonical_coordinate`::

        sage: I.canonical_coordinate()
        t
        sage: t = I.canonical_coordinate()
        sage: type(t)
        <type 'sage.symbolic.expression.Expression'>

    However, it can be obtained in the same step as the interval construction
    by means of the shortcut ``I.<names>``::

        sage: I.<t> = OpenInterval(0, pi)
        sage: t
        t
        sage: type(t)
        <type 'sage.symbolic.expression.Expression'>

    The trick is performed by the Sage preparser::

        sage: preparse("I.<t> = OpenInterval(0, pi)")
        "I = OpenInterval(Integer(0), pi, names=('t',)); (t,) = I._first_ngens(1)"

    In particular the shortcut can be used to set a canonical
    coordinate symbol different from ``'t'``::

        sage: J.<x> = OpenInterval(0, pi)
        sage: J.canonical_chart()
        Chart ((0, pi), (x,))
        sage: J.canonical_coordinate()
        x

    The LaTeX symbol of the canonical coordinate can be adjusted via
    the same syntax as a chart declaration (see
    :class:`~sage.manifolds.chart.RealChart`)::

        sage: J.<x> = OpenInterval(0, pi, coordinate=r'x:\xi')
        sage: latex(x)
        {\xi}
        sage: latex(J.canonical_chart())
        \left(\left(0, \pi\right),({\xi})\right)

    An element of the open interval ``I``::

        sage: x = I.an_element(); x
        Point on the Real interval (0, pi)
        sage: x.coord() # coordinates in the default chart = canonical chart
        (1/2*pi,)

    As for any manifold subset, a specific element of ``I`` can be created
    by providing a tuple containing its coordinate(s) in a given chart::

        sage: x = I((2,)) # (2,) = tuple of coordinates in the canonical chart
        sage: x
        Point on the Real interval (0, pi)

    But for convenience, it can also be created directly from the coordinate::

        sage: x = I(2); x
        Point on the Real interval (0, pi)
        sage: x.coord()
        (2,)
        sage: I(2) == I((2,))
        True

    By default, the coordinates passed for the element ``x`` are those
    relative to the canonical chart::

        sage: I(2) ==  I((2,), chart=I.canonical_chart())
        True

    The lower and upper bounds of the interval ``I``::

        sage: I.lower_bound()
        0
        sage: I.upper_bound()
        pi

    One of the endpoint can be infinite::

        sage: J = OpenInterval(1, +oo); J
        Real interval (1, +Infinity)
        sage: J.an_element().coord()
        (2,)

    The construction of a subinterval can be performed via the argument
    ``ambient_interval`` of ``OpenInterval``::

        sage: J = OpenInterval(0, 1, ambient_interval=I); J
        Real interval (0, 1)

    However, it is recommended to use the method :meth:`open_interval`
    instead::

        sage: J = I.open_interval(0, 1); J
        Real interval (0, 1)
        sage: J.is_subset(I)
        True
        sage: J.manifold() is I
        True

    A subinterval of a subinterval::

        sage: K = J.open_interval(1/2, 1); K
        Real interval (1/2, 1)
        sage: K.is_subset(J)
        True
        sage: K.is_subset(I)
        True
        sage: K.manifold() is I
        True

    We have::

        sage: I.list_of_subsets()
        [Real interval (0, 1), Real interval (0, pi), Real interval (1/2, 1)]
        sage: J.list_of_subsets()
        [Real interval (0, 1), Real interval (1/2, 1)]
        sage: K.list_of_subsets()
        [Real interval (1/2, 1)]

    As any open subset of a manifold, open subintervals are created in a
    category of subobjects of smooth manifolds::

        sage: J.category()
        Join of Category of subobjects of sets and Category of smooth manifolds
         over Real Field with 53 bits of precision
        sage: K.category()
        Join of Category of subobjects of sets and Category of smooth manifolds
         over Real Field with 53 bits of precision

    On the contrary, ``I``, which has not been created as a subinterval,
    is in the category of smooth manifolds (see
    :class:`~sage.categories.manifolds.Manifolds`)::

        sage: I.category()
        Category of smooth manifolds over Real Field with 53 bits of precision

    and we have::

        sage: J.category() is I.category().Subobjects()
        True

    All intervals are parents::

        sage: x = J(1/2); x
        Point on the Real interval (0, pi)
        sage: x.parent() is J
        True
        sage: y = K(3/4); y
        Point on the Real interval (0, pi)
        sage: y.parent() is K
        True

    We have::

        sage: x in I, x in J, x in K
        (True, True, False)
        sage: y in I, y in J, y in K
        (True, True, True)

    The canonical chart of subintervals is inherited from the canonical chart
    of the parent interval::

        sage: XI = I.canonical_chart(); XI
        Chart ((0, pi), (t,))
        sage: XI.coord_range()
        t: (0, pi)
        sage: XJ = J.canonical_chart(); XJ
        Chart ((0, 1), (t,))
        sage: XJ.coord_range()
        t: (0, 1)
        sage: XK = K.canonical_chart(); XK
        Chart ((1/2, 1), (t,))
        sage: XK.coord_range()
        t: (1/2, 1)

    """
    def __init__(self, lower, upper, ambient_interval=None,
                 name=None, latex_name=None,
                 coordinate=None, names=None, start_index=0):
        r"""
        Construct an open interval.

        TESTS::

            sage: I = OpenInterval(-1,1); I
            Real interval (-1, 1)
            sage: TestSuite(I).run(skip='_test_elements')  # pickling of elements fails
            sage: J = OpenInterval(-oo, 2); J
            Real interval (-Infinity, 2)
            sage: TestSuite(J).run(skip='_test_elements')  # pickling of elements fails

        """
        if latex_name is None:
            if name is None:
                latex_name = r"\left({}, {}\right)".format(latex(lower), latex(upper))
            else:
                latex_name = name
        if name is None:
            name = "({}, {})".format(lower, upper)
        if ambient_interval is None:
            ambient_manifold = None
        else:
            if not isinstance(ambient_interval, OpenInterval):
                raise TypeError("the argument ambient_interval must be an open interval")
            ambient_manifold = ambient_interval.manifold()
        field = 'real'
        structure = RealDifferentialStructure()
        DifferentiableManifold.__init__(self, 1, name, field, structure,
                                        base_manifold=ambient_manifold,
                                        latex_name=latex_name,
                                        start_index=start_index)
        if ambient_interval is None:
            if coordinate is None:
                if names is None:
                    coordinate = 't'
                else:
                    coordinate = names[0]
            self._canon_chart = self.chart(coordinates=coordinate)
            t = self._canon_chart[start_index]
        else:
            if lower < ambient_interval.lower_bound():
                raise ValueError("the lower bound is smaller than that of "
                                 + "the containing interval")
            if upper > ambient_interval.upper_bound():
                raise ValueError("the upper bound is larger than that of "
                                 + "the containing interval")
            self._supersets.update(ambient_interval._supersets)
            for sd in ambient_interval._supersets:
                sd._subsets.add(self)
            ambient_interval._top_subsets.add(self)
            t = ambient_interval.canonical_coordinate()
        if lower != minus_infinity:
            if upper != infinity:
                restrictions = [t > lower, t < upper]
            else:
                restrictions = t > lower
        else:
            if upper != infinity:
                restrictions = t < upper
            else:
                restrictions = None
        if ambient_interval is None:
            if restrictions is not None:
                self._canon_chart.add_restrictions(restrictions)
        else:
            self._canon_chart = ambient_interval.canonical_chart().restrict(self,
                                                                            restrictions=restrictions)
        self._lower = lower
        self._upper = upper

    def _repr_(self):
        r"""
        String representation of ``self``.

        TESTS::

            sage: I = OpenInterval(-1, pi)
            sage: I
            Real interval (-1, pi)
            sage: I = OpenInterval(-1, +oo)
            sage: I
            Real interval (-1, +Infinity)
            sage: I = OpenInterval(-oo,0)
            sage: I
            Real interval (-Infinity, 0)

        """
        return "Real interval " + self._name

    def _first_ngens(self, n):
        r"""
        Return the coordinate of the canonical chart.

        This is useful only for the use of Sage preparser.

        INPUT:

        - ``n`` -- the number of coordinates: must be 1

        TESTS::

            sage: I = OpenInterval(-1, 1)
            sage: I._first_ngens(1)
            (t,)
            sage: I = OpenInterval(-1, 1, coordinate='x')
            sage: I._first_ngens(1)
            (x,)
            sage: I = OpenInterval(-1, 1, names=('x',))
            sage: I._first_ngens(1)
            (x,)

        """
        return self._canon_chart[:]

    def _element_constructor_(self, coords=None, chart=None, name=None,
                              latex_name=None, check_coords=True):
        r"""
        Construct an element of ``self``.

        This is a redefinition of
        :meth:`sage.manifolds.differentiable.DifferentiableManifold._element_constructor_`
        to allow for construction from a number (considered as the canonical
        coordinate).

        INPUT:

        - ``coords`` -- (default: ``None``) either (i) the point coordinates
          (as a single-element tuple or list) in the chart ``chart``, (ii) the
          value of the point coordinate in the chart ``chart``, or (iii)
          another point in the interval
        - ``chart`` -- (default: ``None``) chart in which the coordinates are
          given; if none is provided, the coordinates are assumed to refer to
          the interval's default chart
        - ``name`` -- (default: ``None``) name given to the point
        - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the
          point; if none is provided, the LaTeX symbol is set to ``name``
        - ``check_coords`` -- (default: ``True``) determines whether ``coords``
          are valid coordinates for the chart ``chart``; for symbolic
          coordinates, it is recommended to set ``check_coords`` to ``False``

        OUTPUT:

        - :class:`~sage.manifolds.point.TopologicalManifoldPoint`
          representing a point in the current interval

        EXAMPLES::

            sage: I = OpenInterval(-1, 4)
            sage: I((2,))  # standard used of TopologicalManifoldSubset._element_constructor_
            Point on the Real interval (-1, 4)
            sage: I(2)  # specific use with a single coordinate
            Point on the Real interval (-1, 4)
            sage: I(2).coord()
            (2,)
            sage: I(2) == I((2,))
            True
            sage: I(pi)
            Point on the Real interval (-1, 4)
            sage: I(pi).coord()
            (pi,)
            sage: I(8)
            Traceback (most recent call last):
            ...
            ValueError: the coordinates (8,) are not valid on the Chart
             ((-1, 4), (t,))

        """
        if coords in SR:
            coords = (coords,)
        return super(OpenInterval, self)._element_constructor_(coords=coords,
                                 chart=chart, name=name, latex_name=latex_name,
                                 check_coords=check_coords)

    def _Hom_(self, other, category=None):
        r"""
        Construct the set of curves in ``other`` with parameter in ``self``.

        INPUT:

        - ``other`` -- a differentiable manifold `M`
        - ``category`` -- (default: ``None``) not used here (to ensure
          compatibility with generic hook ``_Hom_``)

        OUTPUT:

        - the set of curves `I \to M`,  where `I` is ``self``

        .. SEEALSO::

            :class:`~sage.manifolds.differentiable.manifold_homset.DifferentiableCurveSet`
            for more documentation.

        TESTS::

            sage: I = OpenInterval(-1,1)
            sage: M = Manifold(3, 'M')
            sage: H = I._Hom_(M); H
            Set of Morphisms from Real interval (-1, 1) to 3-dimensional
             differentiable manifold M in Category of smooth manifolds over
             Real Field with 53 bits of precision
            sage: H is Hom(I, M)
            True

        """
        from sage.manifolds.differentiable.manifold_homset import DifferentiableCurveSet
        return DifferentiableCurveSet(self, other)

    def canonical_chart(self):
        r"""
        Return the canonical chart defined on ``self``.

        OUTPUT:

        - :class:`~sage.manifolds.differentiable.chart.RealDiffChart`

        EXAMPLES:

        Canonical chart on the interval `(0, \pi)`::

            sage: I = OpenInterval(0, pi)
            sage: I.canonical_chart()
            Chart ((0, pi), (t,))
            sage: I.canonical_chart().coord_range()
            t: (0, pi)

        The symbol used for the coordinate of the canonical chart is that
        defined during the construction of the interval::

            sage: I.<x> = OpenInterval(0, pi)
            sage: I.canonical_chart()
            Chart ((0, pi), (x,))

        """
        return self._canon_chart

    def canonical_coordinate(self):
        r"""
        Return the canonical coordinate defined on the interval.

        OUTPUT:

        - the symbolic variable representing the canonical coordinate

        EXAMPLES:

        Canonical coordinate on the interval `(0, \pi)`::

            sage: I = OpenInterval(0, pi)
            sage: I.canonical_coordinate()
            t
            sage: type(I.canonical_coordinate())
            <type 'sage.symbolic.expression.Expression'>
            sage: I.canonical_coordinate().is_real()
            True

        The canonical coordinate is the first (unique) coordinate of the
        canonical chart::

            sage: I.canonical_coordinate() is I.canonical_chart()[0]
            True

        Its default symbol is `t`; but it can be customized during the
        creation of the interval::

            sage: I = OpenInterval(0, pi, coordinate='x')
            sage: I.canonical_coordinate()
            x
            sage: I.<x> = OpenInterval(0, pi)
            sage: I.canonical_coordinate()
            x

        """
        return self._canon_chart._xx[0]

    def lower_bound(self):
        r"""
        Return the lower bound (infimum) of the interval.

        EXAMPLES::

            sage: I = OpenInterval(1/4, 3)
            sage: I.lower_bound()
            1/4
            sage: J = OpenInterval(-oo, 2)
            sage: J.lower_bound()
            -Infinity

        An alias of :meth:`lower_bound` is :meth:`inf`::

            sage: I.inf()
            1/4
            sage: J.inf()
            -Infinity

        """
        return self._lower

    inf = lower_bound

    def upper_bound(self):
        r"""
        Return the upper bound (supremum) of the interval.

        EXAMPLES::

            sage: I = OpenInterval(1/4, 3)
            sage: I.upper_bound()
            3
            sage: J = OpenInterval(1, +oo)
            sage: J.upper_bound()
            +Infinity

        An alias of :meth:`upper_bound` is :meth:`sup`::

            sage: I.sup()
            3
            sage: J.sup()
            +Infinity

        """
        return self._upper

    sup = upper_bound

    def open_interval(self, lower, upper, name=None, latex_name=None):
        r"""
        Define an open subinterval of ``self``.

        INPUT:

        - ``lower`` -- lower bound of the subinterval (possibly ``-Infinity``)
        - ``upper`` -- upper bound of the subinterval (possibly ``+Infinity``)
        - ``name`` -- (default: ``None``) string; name (symbol) given to the
          subinterval; if ``None``, the name is constructed from ``lower`` and
          ``upper``
        - ``latex_name`` -- (default: ``None``) string; LaTeX symbol to denote
          the subinterval; if ``None``, the LaTeX symbol is constructed from
          ``lower`` and ``upper`` if ``name`` is ``None``, otherwise, it is set
          to ``name``

        OUTPUT:

        - :class:`~sage.manifolds.differentiable.real_line.OpenInterval`
          representing the open interval (``lower``, ``upper``)

        EXAMPLES:

        The interval `(0, \pi)` as a subinterval of `(-4, 4)`::

            sage: I = OpenInterval(-4, 4)
            sage: J = I.open_interval(0, pi); J
            Real interval (0, pi)
            sage: J.is_subset(I)
            True
            sage: I.list_of_subsets()
            [Real interval (-4, 4), Real interval (0, pi)]

        ``J`` is considered as an open submanifold of ``I``::

            sage: J.manifold() is I
            True

        The subinterval `(-4, 4)` is ``I`` itself::

            sage: I.open_interval(-4, 4) is I
            True

        """
        if lower == self._lower and upper == self._upper:
            return self
        # To cope with the unique representation framework, we have to
        # distinguish several cases, instead of performing a mere
        # return OpenInterval(lower, upper, ambient_interval=self, name=name,
        #                     latex_name=latex_name)
        if name is None:
            if latex_name is None:
                return OpenInterval(lower, upper, ambient_interval=self)
            return OpenInterval(lower, upper, ambient_interval=self,
                                latex_name=latex_name)
        if latex_name is None:
            return OpenInterval(lower, upper, ambient_interval=self, name=name)
        return OpenInterval(lower, upper, ambient_interval=self, name=name,
                            latex_name=latex_name)


#******************************************************************************

class RealLine(OpenInterval):
    r"""
    Field of real numbers, as a differentiable manifold of dimension 1 (real
    line) with a canonical coordinate chart.

    INPUT:

    - ``name`` -- (default: ``'R'``) string; name (symbol) given to
      the real line
    - ``latex_name`` -- (default: ``r'\Bold{R}'``) string; LaTeX symbol to
      denote the real line
    - ``coordinate`` -- (default: ``None``) string defining the symbol of the
      canonical coordinate set on the real line; if none is provided and
      ``names`` is ``None``, the symbol 't' is used
    - ``names`` -- (default: ``None``) used only when ``coordinate`` is
      ``None``: it must be a single-element tuple containing the canonical
      coordinate symbol (this is guaranteed if the shortcut ``<names>`` is
      used, see examples below)
    - ``start_index`` -- (default: 0) unique value of the index for vectors
      and forms on the real line manifold

    EXAMPLES:

    Constructing the real line without any argument::

        sage: R = RealLine() ; R
        Real number line R
        sage: latex(R)
        \Bold{R}

    ``R`` is a 1-dimensional real smooth manifold::

        sage: R.category()
        Category of smooth manifolds over Real Field with 53 bits of precision
        sage: isinstance(R, sage.manifolds.differentiable.manifold.DifferentiableManifold)
        True
        sage: dim(R)
        1

    It is endowed with a canonical chart::

        sage: R.canonical_chart()
        Chart (R, (t,))
        sage: R.canonical_chart() is R.default_chart()
        True
        sage: R.atlas()
        [Chart (R, (t,))]

    The instance is unique (as long as the constructor arguments are the
    same)::

        sage: R is RealLine()
        True
        sage: R is RealLine(latex_name='R')
        False

    The canonical coordinate is returned by the method
    :meth:`~sage.manifolds.differentiable.real_line.OpenInterval.canonical_coordinate`::

        sage: R.canonical_coordinate()
        t
        sage: t = R.canonical_coordinate()
        sage: type(t)
        <type 'sage.symbolic.expression.Expression'>

    However, it can be obtained in the same step as the real line construction
    by means of the shortcut ``R.<names>``::

        sage: R.<t> = RealLine()
        sage: t
        t
        sage: type(t)
        <type 'sage.symbolic.expression.Expression'>

    The trick is performed by Sage preparser::

        sage: preparse("R.<t> = RealLine()")
        "R = RealLine(names=('t',)); (t,) = R._first_ngens(1)"

    In particular the shortcut is to be used to set a canonical
    coordinate symbol different from 't'::

        sage: R.<x> = RealLine()
        sage: R.canonical_chart()
        Chart (R, (x,))
        sage: R.atlas()
        [Chart (R, (x,))]
        sage: R.canonical_coordinate()
        x

    The LaTeX symbol of the canonical coordinate can be adjusted via the same
    syntax as a chart declaration (see
    :class:`~sage.manifolds.chart.RealChart`)::

        sage: R.<x> = RealLine(coordinate=r'x:\xi')
        sage: latex(x)
        {\xi}
        sage: latex(R.canonical_chart())
        \left(\Bold{R},({\xi})\right)

    The LaTeX symbol of the real line itself can also be customized::

        sage: R.<x> = RealLine(latex_name=r'\mathbb{R}')
        sage: latex(R)
        \mathbb{R}

    Elements of the real line can be constructed directly from a number::

        sage: p = R(2) ; p
        Point on the Real number line R
        sage: p.coord()
        (2,)
        sage: p = R(1.742) ; p
        Point on the Real number line R
        sage: p.coord()
        (1.74200000000000,)

    Symbolic variables can also be used::

        sage: p = R(pi, name='pi') ; p
        Point pi on the Real number line R
        sage: p.coord()
        (pi,)
        sage: a = var('a')
        sage: p = R(a) ; p
        Point on the Real number line R
        sage: p.coord()
        (a,)

    The real line is considered as the open interval `(-\infty, +\infty)`::

        sage: isinstance(R, sage.manifolds.differentiable.real_line.OpenInterval)
        True
        sage: R.lower_bound()
        -Infinity
        sage: R.upper_bound()
        +Infinity

    A real interval can be created from ``R`` means of the method
    :meth:`~sage.manifolds.differentiable.real_line.OpenInterval.open_interval`::

        sage: I = R.open_interval(0, 1); I
        Real interval (0, 1)
        sage: I.manifold()
        Real number line R
        sage: R.list_of_subsets()
        [Real interval (0, 1), Real number line R]

    """
    def __init__(self, name='R', latex_name=r'\Bold{R}', coordinate=None,
                 names=None, start_index=0):
        r"""
        Construct the real line manifold.

        TESTS::

            sage: R = RealLine() ; R
            Real number line R
            sage: R.category()
            Category of smooth manifolds over Real Field with 53 bits of precision
            sage: TestSuite(R).run(skip='_test_elements')  # pickling of elements fails

        """
        OpenInterval.__init__(self, minus_infinity, infinity, name=name,
                              latex_name=latex_name, coordinate=coordinate,
                              names=names, start_index=start_index)

    def _repr_(self):
        r"""
        String representation of ``self``.

        TESTS::

            sage: R = RealLine()
            sage: R._repr_()
            'Real number line R'
            sage: R = RealLine(name='r')
            sage: R._repr_()
            'Real number line r'

        """
        return "Real number line " + self._name

