summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorTravis Scrimshaw <tscrimsh at umn.edu>2016-05-07 13:10:07 -0500
committerTravis Scrimshaw <tscrimsh at umn.edu>2016-05-07 13:10:07 -0500
commit4fad094762f5b24475d0d0c9f6003d549e4abcc7 (patch)
tree8ddcd82fe7e3d273f891ec83a13231f7635a7203
parentUpdated SageMath version to 7.2.rc1 (diff)
parentPython3 format for print in morphims of topological manifolds (diff)
Merge branch 'public/manifolds/top_manif_morphisms' of trac.sagemath.org:sage into public/manifolds/top_manif_morphisms
-rw-r--r--src/doc/en/reference/manifolds/chart.rst11
-rw-r--r--src/doc/en/reference/manifolds/continuous_map.rst9
-rw-r--r--src/doc/en/reference/manifolds/index.rst4
-rw-r--r--src/doc/en/reference/manifolds/manifold.rst6
-rw-r--r--src/doc/en/reference/manifolds/scalarfield.rst9
-rw-r--r--src/sage/doctest/sources.py1
-rw-r--r--src/sage/manifolds/chart.py881
-rw-r--r--src/sage/manifolds/continuous_map.py1830
-rw-r--r--src/sage/manifolds/coord_func.py1451
-rw-r--r--src/sage/manifolds/coord_func_symb.py1762
-rw-r--r--src/sage/manifolds/manifold.py694
-rw-r--r--src/sage/manifolds/manifold_homset.py422
-rw-r--r--src/sage/manifolds/point.py230
-rw-r--r--src/sage/manifolds/scalarfield.py2773
-rw-r--r--src/sage/manifolds/scalarfield_algebra.py621
-rw-r--r--src/sage/manifolds/structure.py6
-rw-r--r--src/sage/manifolds/utilities.py890
17 files changed, 11535 insertions, 65 deletions
diff --git a/src/doc/en/reference/manifolds/chart.rst b/src/doc/en/reference/manifolds/chart.rst
new file mode 100644
index 0000000..0ba9dc6
--- /dev/null
+++ b/src/doc/en/reference/manifolds/chart.rst
@@ -0,0 +1,11 @@
+Coordinate Charts
+=================
+
+.. toctree::
+ :maxdepth: 2
+
+ sage/manifolds/chart
+
+ sage/manifolds/coord_func
+
+ sage/manifolds/coord_func_symb
diff --git a/src/doc/en/reference/manifolds/continuous_map.rst b/src/doc/en/reference/manifolds/continuous_map.rst
new file mode 100644
index 0000000..9c4afeb
--- /dev/null
+++ b/src/doc/en/reference/manifolds/continuous_map.rst
@@ -0,0 +1,9 @@
+Continuous Maps
+===============
+
+.. toctree::
+ :maxdepth: 2
+
+ sage/manifolds/manifold_homset
+
+ sage/manifolds/continuous_map
diff --git a/src/doc/en/reference/manifolds/index.rst b/src/doc/en/reference/manifolds/index.rst
index f0d5932..13995d6 100644
--- a/src/doc/en/reference/manifolds/index.rst
+++ b/src/doc/en/reference/manifolds/index.rst
@@ -11,8 +11,10 @@ More documentation (in particular example worksheets) can be found
`here <http://sagemanifolds.obspm.fr/documentation.html>`_.
.. toctree::
- :maxdepth: 2
+ :maxdepth: 3
manifold
+ sage/manifolds/utilities
+
.. include:: ../footer.txt
diff --git a/src/doc/en/reference/manifolds/manifold.rst b/src/doc/en/reference/manifolds/manifold.rst
index d9364a3..5b1c860 100644
--- a/src/doc/en/reference/manifolds/manifold.rst
+++ b/src/doc/en/reference/manifolds/manifold.rst
@@ -12,4 +12,8 @@ Topological Manifolds
sage/manifolds/point
- sage/manifolds/chart
+ chart
+
+ scalarfield
+
+ continuous_map
diff --git a/src/doc/en/reference/manifolds/scalarfield.rst b/src/doc/en/reference/manifolds/scalarfield.rst
new file mode 100644
index 0000000..3ba7a2e
--- /dev/null
+++ b/src/doc/en/reference/manifolds/scalarfield.rst
@@ -0,0 +1,9 @@
+Scalar Fields
+=============
+
+.. toctree::
+ :maxdepth: 2
+
+ sage/manifolds/scalarfield_algebra
+
+ sage/manifolds/scalarfield
diff --git a/src/sage/doctest/sources.py b/src/sage/doctest/sources.py
index afd2562..67d2c5f 100644
--- a/src/sage/doctest/sources.py
+++ b/src/sage/doctest/sources.py
@@ -717,6 +717,7 @@ class FileDocTestSource(DocTestSource):
There are 8 tests in sage/combinat/root_system/type_G.py that are not being run
There are 3 unexpected tests being run in sage/doctest/parsing.py
There are 1 unexpected tests being run in sage/doctest/reporting.py
+ There are 15 tests in sage/manifolds/manifold.py that are not being run
There are 3 tests in sage/rings/invariant_theory.py that are not being run
sage: os.chdir(cwd)
"""
diff --git a/src/sage/manifolds/chart.py b/src/sage/manifolds/chart.py
index 6a6194b..bc081ab 100644
--- a/src/sage/manifolds/chart.py
+++ b/src/sage/manifolds/chart.py
@@ -5,6 +5,8 @@ The class :class:`Chart` implements coordinate charts on a topological
manifold over a topological field `K`. The subclass :class:`RealChart`
is devoted to the case `K=\RR`, for which the concept of coordinate
range is meaningful.
+Moreover, :class:`RealChart` is endowed with some plotting
+capabilities (cf. method :meth:`~sage.manifolds.chart.RealChart.plot`).
Transition maps between charts are implemented via the class
:class:`CoordChange`.
@@ -16,10 +18,10 @@ AUTHORS:
REFERENCES:
-- Chap. 2 of [Lee11]_ J.M. Lee: *Introduction to Topological Manifolds*,
+- Chap. 2 of [Lee11]_ \J.M. Lee: *Introduction to Topological Manifolds*,
2nd ed., Springer (New York) (2011)
-- Chap. 1 of [Lee13]_ J.M. Lee : *Introduction to Smooth Manifolds*,
+- Chap. 1 of [Lee13]_ \J.M. Lee : *Introduction to Smooth Manifolds*,
2nd ed., Springer (New York) (2013)
"""
@@ -40,6 +42,7 @@ from sage.structure.unique_representation import UniqueRepresentation
from sage.symbolic.ring import SR
from sage.rings.infinity import Infinity
from sage.misc.latex import latex
+from sage.manifolds.coord_func_symb import CoordFunctionSymb
class Chart(UniqueRepresentation, SageObject):
r"""
@@ -309,6 +312,17 @@ class Chart(UniqueRepresentation, SageObject):
self._dom_restrict = {} # dict. of the restrictions of self to
# subsets of self._domain, with the
# subsets as keys
+ # The null and one functions of the coordinates:
+ base_field_type = self._domain.base_field_type()
+ # Expression in self of the zero and one scalar fields of open sets
+ # containing the domain of self:
+ for dom in self._domain._supersets:
+ if hasattr(dom, '_zero_scalar_field'):
+ # dom is an open set
+ dom._zero_scalar_field._express[self] = self.function_ring().zero()
+ if hasattr(dom, '_one_scalar_field'):
+ # dom is an open set
+ dom._one_scalar_field._express[self] = self.function_ring().one()
def _init_coordinates(self, coord_list):
r"""
@@ -825,6 +839,252 @@ class Chart(UniqueRepresentation, SageObject):
transformations = [transformations]
return CoordChange(chart1, chart2, *transformations)
+ def function_ring(self):
+ """
+ Return the ring of coordinate functions on ``self``.
+
+ EXAMPLES::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: X.function_ring()
+ Ring of coordinate functions on Chart (M, (x, y))
+ """
+ from sage.manifolds.coord_func_symb import CoordFunctionSymbRing
+ return CoordFunctionSymbRing(self)
+
+ def function(self, expression):
+ r"""
+ Define a coordinate function to the base field.
+
+ If the current chart belongs to the atlas of a `n`-dimensional manifold
+ over a topological field `K`, a *coordinate function* is a map
+
+ .. MATH::
+
+ \begin{array}{cccc}
+ f:& V\subset K^n & \longrightarrow & K \\
+ & (x^1,\ldots, x^n) & \longmapsto & f(x^1,\ldots, x^n),
+ \end{array}
+
+ where `V` is the chart codomain and `(x^1,\ldots, x^n)` are the
+ chart coordinates.
+
+ The coordinate function can be either a symbolic one or a numerical
+ one, depending on the parameter ``expression`` (see below).
+
+ See :class:`~sage.manifolds.coord_func.CoordFunction`
+ and :class:`~sage.manifolds.coord_func_symb.CoordFunctionSymb`
+ for a complete documentation.
+
+ INPUT:
+
+ - ``expression`` -- material defining the coordinate function; it can
+ be either:
+
+ - a symbolic expression involving the chart coordinates, to represent
+ `f(x^1,\ldots, x^n)`
+ - a string representing the name of a file where the data
+ to construct a numerical coordinate function is stored
+
+ OUTPUT:
+
+ - instance of a subclass of the base class
+ :class:`~sage.manifolds.coord_func.CoordFunction`
+ representing the coordinate function `f`; this is
+ :class:`~sage.manifolds.coord_func_symb.CoordFunctionSymb` if
+ if ``expression`` is a symbolic expression.
+
+ EXAMPLES:
+
+ A symbolic coordinate function::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = X.function(sin(x*y))
+ sage: f
+ sin(x*y)
+ sage: type(f)
+ <class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category.element_class'>
+ sage: f.display()
+ (x, y) |--> sin(x*y)
+ sage: f(2,3)
+ sin(6)
+
+ """
+ if isinstance(expression, str):
+ raise NotImplementedError("numerical coordinate function not " +
+ "implemented yet")
+ else:
+ return self.function_ring()(expression)
+
+ def zero_function(self):
+ r"""
+ Return the zero function of the coordinates.
+
+ If the current chart belongs to the atlas of a `n`-dimensional manifold
+ over a topological field `K`, the zero coordinate function is the map
+
+ .. MATH::
+
+ \begin{array}{cccc}
+ f:& V\subset K^n & \longrightarrow & K \\
+ & (x^1,\ldots, x^n) & \longmapsto & 0,
+ \end{array}
+
+ where `V` is the chart codomain.
+
+ See class :class:`~sage.manifolds.coord_func_symb.CoorFunctionSymb`
+ for a complete documentation.
+ OUTPUT:
+
+ - instance of class
+ :class:`~sage.manifolds.coord_func_symb.CoorFunctionSymb`
+ representing the zero coordinate function `f`.
+
+ EXAMPLES::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: X.zero_function()
+ 0
+ sage: X.zero_function().display()
+ (x, y) |--> 0
+ sage: type(X.zero_function())
+ <class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category.element_class'>
+
+ The result is cached::
+
+ sage: X.zero_function() is X.zero_function()
+ True
+
+ Zero function on a p-adic manifold::
+
+ sage: M = Manifold(2, 'M', structure='topological', field=Qp(5)); M
+ 2-dimensional topological manifold M over the 5-adic Field with
+ capped relative precision 20
+ sage: X.<x,y> = M.chart()
+ sage: X.zero_function()
+ 0
+ sage: X.zero_function().display()
+ (x, y) |--> 0
+
+ """
+ return self.function_ring().zero()
+
+ def one_function(self):
+ r"""
+ Return the constant function of the coordinates equal to one.
+
+ If the current chart belongs to the atlas of a `n`-dimensional manifold
+ over a topological field `K`, the "one" coordinate function is the map
+
+ .. MATH::
+
+ \begin{array}{cccc}
+ f:& V\subset K^n & \longrightarrow & K \\
+ & (x^1,\ldots, x^n) & \longmapsto & 1,
+ \end{array}
+
+ where `V` is the chart codomain.
+
+ See class :class:`~sage.manifolds.coord_func_symb.CoorFunctionSymb`
+ for a complete documentation.
+ OUTPUT:
+
+ - instance of class
+ :class:`~sage.manifolds.coord_func_symb.CoorFunctionSymb`
+ representing the one coordinate function `f`.
+
+ EXAMPLES::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: X.one_function()
+ 1
+ sage: X.one_function().display()
+ (x, y) |--> 1
+ sage: type(X.one_function())
+ <class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category.element_class'>
+
+ The result is cached::
+
+ sage: X.one_function() is X.one_function()
+ True
+
+ One function on a p-adic manifold::
+
+ sage: M = Manifold(2, 'M', structure='topological', field=Qp(5)); M
+ 2-dimensional topological manifold M over the 5-adic Field with
+ capped relative precision 20
+ sage: X.<x,y> = M.chart()
+ sage: X.one_function()
+ 1 + O(5^20)
+ sage: X.one_function().display()
+ (x, y) |--> 1 + O(5^20)
+
+ """
+ return self.function_ring().one()
+
+
+ def multifunction(self, *expressions):
+ r"""
+ Define a coordinate function to some Cartesian power of the base field.
+
+ If `n` and `m` are two positive integers and `(U, \varphi)` is a
+ chart on a topological manifold `M` of dimension `n` over a
+ topological field `K`, a *multi-coordinate function* associated
+ to `(U,\varphi)` is a map
+
+ .. MATH::
+
+ \begin{array}{llcl}
+ f:& V \subset K^n & \longrightarrow & K^m \\
+ & (x^1, \ldots, x^n) & \longmapsto & (f_1(x^1, \ldots, x^n),
+ \ldots, f_m(x^1, \ldots, x^n)),
+ \end{array}
+
+ where `V` is the codomain of `\varphi`. In other words, `f` is a
+ `K^m`-valued function of the coordinates associated to the chart
+ `(U,\varphi)`.
+
+ See :class:`~sage.manifolds.coord_func.MultiCoordFunction` for a
+ complete documentation.
+
+ INPUT:
+
+ - ``expressions`` -- list (or tuple) of `m` elements to construct the
+ coordinate functions `f_i` (`1\leq i \leq m`); for
+ symbolic coordinate functions, this must be symbolic expressions
+ involving the chart coordinates, while for numerical coordinate
+ functions, this must be data file names
+
+ OUTPUT:
+
+ - a :class:`~sage.manifolds.coord_func.MultiCoordFunction`
+ representing `f`
+
+ EXAMPLES:
+
+ Function of two coordinates with values in `\RR^3`::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = X.multifunction(x+y, sin(x*y), x^2 + 3*y); f
+ Coordinate functions (x + y, sin(x*y), x^2 + 3*y) on the Chart (M, (x, y))
+ sage: f(2,3)
+ (5, sin(6), 13)
+
+ TESTS::
+
+ sage: type(f)
+ <class 'sage.manifolds.coord_func.MultiCoordFunction'>
+
+ """
+ from sage.manifolds.coord_func import MultiCoordFunction
+ return MultiCoordFunction(self, expressions)
+
+
#*****************************************************************************
class RealChart(Chart):
@@ -951,8 +1211,8 @@ class RealChart(Chart):
Coordinate are also accessible by their indices::
sage: x1 = c_spher[1]; x2 = c_spher[2]; x3 = c_spher[3]
- sage: print x1, x2, x3
- r th ph
+ sage: [x1, x2, x3]
+ [r, th, ph]
sage: (x1, x2, x3) == (r, th, ph)
True
@@ -1050,6 +1310,10 @@ class RealChart(Chart):
*and* `x < 0`::
c_cartU.add_restrictions([y!=0, x<0])
+
+ Chart grids can be drawn in 2D or 3D graphics thanks to the method
+ :meth:`plot`.
+
"""
def __init__(self, domain, coordinates='', names=None):
r"""
@@ -1412,6 +1676,7 @@ class RealChart(Chart):
self._bounds = tuple(bounds)
self._restrictions = new_restrictions
+
def restrict(self, subset, restrictions=None):
r"""
Return the restriction of the chart to some open subset of its domain.
@@ -1599,6 +1864,555 @@ class RealChart(Chart):
# All tests have been passed:
return True
+ def plot(self, chart=None, ambient_coords=None, mapping=None,
+ fixed_coords=None, ranges=None, max_range=8, nb_values=None,
+ steps=None, parameters=None, color='red', style='-', thickness=1,
+ plot_points=75, label_axes=True):
+ r"""
+ Plot the current chart as a "grid" in a Cartesian graph
+ based on the coordinates of some ambient chart.
+
+ The "grid" is formed by curves along which a chart coordinate
+ varies, the other coordinates being kept fixed; it is drawn in terms of
+ two (2D graphics) or three (3D graphics) coordinates of another chart,
+ called hereafter the *ambient chart*.
+
+ The ambient chart is related to the current chart either by
+ a transition map if both charts are defined on the same manifold, or by
+ the coordinate expression of some continuous map (typically an
+ immersion). In the latter case, the two charts may be defined on two
+ different manifolds.
+
+ INPUT:
+
+ - ``chart`` -- (default: ``None``) the ambient chart (see above); if
+ ``None``, the ambient chart is set to the current chart
+ - ``ambient_coords`` -- (default: ``None``) tuple containing the 2 or 3
+ coordinates of the ambient chart in terms of which the plot is
+ performed; if ``None``, all the coordinates of the ambient chart are
+ considered
+ - ``mapping`` -- (default: ``None``) continuous manifold map (instance
+ of :class:`~sage.manifolds.continuous_map.ContinuousMap`)
+ providing the link between the current chart and the ambient chart
+ (cf. above); if ``None``, both charts are supposed to be defined on
+ the same manifold and related by some transition map (see
+ :meth:`~sage.manifolds.chart.Chart.transition_map`)
+ - ``fixed_coords`` -- (default: ``None``) dictionary with keys the
+ chart coordinates that are not drawn and with values the fixed
+ value of these coordinates; if ``None``, all the coordinates of the
+ current chart are drawn
+ - ``ranges`` -- (default: ``None``) dictionary with keys the coordinates
+ to be drawn and values tuples ``(x_min,x_max)`` specifying the
+ coordinate range for the plot; if ``None``, the entire coordinate
+ range declared during the chart construction is considered (with
+ -Infinity replaced by ``-max_range`` and +Infinity by ``max_range``)
+ - ``max_range`` -- (default: 8) numerical value substituted to
+ +Infinity if the latter is the upper bound of the range of a
+ coordinate for which the plot is performed over the entire coordinate
+ range (i.e. for which no specific plot range has been set in
+ ``ranges``); similarly ``-max_range`` is the numerical valued
+ substituted for -Infinity
+ - ``nb_values`` -- (default: ``None``) either an integer or a dictionary
+ with keys the coordinates to be drawn and values the number of
+ constant values of the coordinate to be considered; if ``nb_values``
+ is a single integer, it represents the number of constant values for
+ all coordinates; if ``nb_values`` is ``None``, it is set to 9 for a
+ 2D plot and to 5 for a 3D plot
+ - ``steps`` -- (default: ``None``) dictionary with keys the coordinates
+ to be drawn and values the step between each constant value of
+ the coordinate; if ``None``, the step is computed from the coordinate
+ range (specified in ``ranges``) and ``nb_values``. On the contrary
+ if the step is provided for some coordinate, the corresponding
+ number of constant values is deduced from it and the coordinate range.
+ - ``parameters`` -- (default: ``None``) dictionary giving the numerical
+ values of the parameters that may appear in the relation between
+ the two coordinate systems
+ - ``color`` -- (default: 'red') either a single color or a dictionary
+ of colors, with keys the coordinates to be drawn, representing the
+ colors of the lines along which the coordinate varies, the other
+ being kept constant; if ``color`` is a single color, it is used for
+ all coordinate lines
+ - ``style`` -- (default: '-') either a single line style or a dictionary
+ of line styles, with keys the coordinates to be drawn, representing
+ the style of the lines along which the coordinate varies, the other
+ being kept constant; if ``style`` is a single style, it is used for
+ all coordinate lines; NB: ``style`` is effective only for 2D plots
+ - ``thickness`` -- (default: 1) either a single line thickness or a
+ dictionary of line thicknesses, with keys the coordinates to be drawn,
+ representing the thickness of the lines along which the coordinate
+ varies, the other being kept constant; if ``thickness`` is a single
+ value, it is used for all coordinate lines
+ - ``plot_points`` -- (default: 75) either a single number of points or
+ a dictionary of integers, with keys the coordinates to be drawn,
+ representing the number of points to plot the lines along which the
+ coordinate varies, the other being kept constant; if ``plot_points``
+ is a single integer, it is used for all coordinate lines
+ - ``label_axes`` -- (default: ``True``) boolean determining whether the
+ labels of the ambient coordinate axes shall be added to the graph;
+ can be set to False if the graph is 3D and must be superposed with
+ another graph.
+
+ OUTPUT:
+
+ - a graphic object, either an instance of
+ :class:`~sage.plot.graphics.Graphics` for a 2D plot (i.e. based on
+ 2 coordinates of the ambient chart) or an instance of
+ :class:`~sage.plot.plot3d.base.Graphics3d` for a 3D plot (i.e.
+ based on 3 coordinates of the ambient chart)
+
+ EXAMPLES:
+
+ Grid of polar coordinates in terms of Cartesian coordinates in the
+ Euclidean plane::
+
+ sage: R2 = Manifold(2, 'R^2', structure='topological') # the Euclidean plane
+ sage: c_cart.<x,y> = R2.chart() # Cartesian coordinates
+ sage: U = R2.open_subset('U', coord_def={c_cart: (y!=0, x<0)}) # the complement of the segment y=0 and x>0
+ sage: c_pol.<r,ph> = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi') # polar coordinates on U
+ sage: pol_to_cart = c_pol.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ sage: g = c_pol.plot(c_cart)
+ sage: type(g)
+ <class 'sage.plot.graphics.Graphics'>
+ sage: show(g) # graphical display
+
+ .. PLOT::
+
+ R2 = Manifold(2, 'R^2', structure='topological')
+ c_cart = R2.chart('x y'); x, y = c_cart[:]
+ U = R2.open_subset('U', coord_def={c_cart: (y!=0, x<0)})
+ c_pol = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi'); r, ph = c_pol[:]
+ pol_to_cart = c_pol.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ g = c_pol.plot(c_cart)
+ sphinx_plot(g)
+
+ Call with non-default values::
+
+ sage: g = c_pol.plot(c_cart, ranges={ph:(pi/4,pi)}, nb_values={r:7, ph:17},
+ ....: color={r:'red', ph:'green'}, style={r:'-', ph:'--'})
+
+ .. PLOT::
+
+ R2 = Manifold(2, 'R^2', structure='topological')
+ c_cart = R2.chart('x y'); x, y = c_cart[:]
+ U = R2.open_subset('U', coord_def={c_cart: (y!=0, x<0)})
+ c_pol = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi'); r, ph = c_pol[:]
+ pol_to_cart = c_pol.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ g = c_pol.plot(c_cart, ranges={ph:(pi/4,pi)}, nb_values={r:7, ph:17}, \
+ color={r:'red', ph:'green'}, style={r:'-', ph:'--'})
+ sphinx_plot(g)
+
+ A single coordinate line can be drawn::
+
+ sage: g = c_pol.plot(c_cart, fixed_coords={r: 2}) # draw a circle of radius r=2
+
+ .. PLOT::
+
+ R2 = Manifold(2, 'R^2', structure='topological')
+ c_cart = R2.chart('x y'); x, y = c_cart[:]
+ U = R2.open_subset('U', coord_def={c_cart: (y!=0, x<0)})
+ c_pol = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi'); r, ph = c_pol[:]
+ pol_to_cart = c_pol.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ g = c_pol.plot(c_cart, fixed_coords={r: 2})
+ sphinx_plot(g)
+
+ ::
+
+ sage: g = c_pol.plot(c_cart, fixed_coords={ph: pi/4}) # draw a segment at phi=pi/4
+
+ .. PLOT::
+
+ R2 = Manifold(2, 'R^2', structure='topological')
+ c_cart = R2.chart('x y'); x, y = c_cart[:]
+ U = R2.open_subset('U', coord_def={c_cart: (y!=0, x<0)})
+ c_pol = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi'); r, ph = c_pol[:]
+ pol_to_cart = c_pol.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ g = c_pol.plot(c_cart, fixed_coords={ph: pi/4})
+ sphinx_plot(g)
+
+ A chart can be plotted in terms of itself, resulting in a rectangular
+ grid::
+
+ sage: g = c_cart.plot() # equivalent to c_cart.plot(c_cart)
+ sage: show(g) # a rectangular grid
+
+ .. PLOT::
+
+ R2 = Manifold(2, 'R^2', structure='topological')
+ c_cart = R2.chart('x y'); x, y = c_cart[:]
+ g = c_cart.plot()
+ sphinx_plot(g)
+
+ An example with the ambient chart given by the coordinate expression of
+ some manifold map: 3D plot of the stereographic charts on the
+ 2-sphere::
+
+ sage: S2 = Manifold(2, 'S^2', structure='topological') # the 2-sphere
+ sage: U = S2.open_subset('U') ; V = S2.open_subset('V') # complement of the North and South pole, respectively
+ sage: S2.declare_union(U,V)
+ sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+ sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+ sage: xy_to_uv = c_xy.transition_map(c_uv, (x/(x^2+y^2), y/(x^2+y^2)),
+ ....: intersection_name='W', restrictions1= x^2+y^2!=0,
+ ....: restrictions2= u^2+v^2!=0)
+ sage: uv_to_xy = xy_to_uv.inverse()
+ sage: R3 = Manifold(3, 'R^3', structure='topological') # the Euclidean space R^3
+ sage: c_cart.<X,Y,Z> = R3.chart() # Cartesian coordinates on R^3
+ sage: Phi = S2.continuous_map(R3, {(c_xy, c_cart): [2*x/(1+x^2+y^2),
+ ....: 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)],
+ ....: (c_uv, c_cart): [2*u/(1+u^2+v^2),
+ ....: 2*v/(1+u^2+v^2), (1-u^2-v^2)/(1+u^2+v^2)]},
+ ....: name='Phi', latex_name=r'\Phi') # Embedding of S^2 in R^3
+ sage: g = c_xy.plot(c_cart, mapping=Phi)
+ sage: show(g) # 3D graphic display
+ sage: type(g)
+ <class 'sage.plot.plot3d.base.Graphics3dGroup'>
+
+ The same plot without the (X,Y,Z) axes labels::
+
+ sage: g = c_xy.plot(c_cart, mapping=Phi, label_axes=False)
+
+ The North and South stereographic charts on the same plot::
+
+ sage: g2 = c_uv.plot(c_cart, mapping=Phi, color='green')
+ sage: show(g+g2)
+
+ South stereographic chart drawned in terms of the North one (we split
+ the plot in four parts to avoid the singularity at (u,v)=(0,0))::
+
+ sage: W = U.intersection(V) # the subset common to both charts
+ sage: c_uvW = c_uv.restrict(W) # chart (W,(u,v))
+ sage: gSN1 = c_uvW.plot(c_xy, ranges={u:[-6.,-0.02], v:[-6.,-0.02]})
+ sage: gSN2 = c_uvW.plot(c_xy, ranges={u:[-6.,-0.02], v:[0.02,6.]})
+ sage: gSN3 = c_uvW.plot(c_xy, ranges={u:[0.02,6.], v:[-6.,-0.02]})
+ sage: gSN4 = c_uvW.plot(c_xy, ranges={u:[0.02,6.], v:[0.02,6.]})
+ sage: show(gSN1+gSN2+gSN3+gSN4, xmin=-1.5, xmax=1.5, ymin=-1.5, ymax=1.5)
+
+ .. PLOT::
+
+ S2 = Manifold(2, 'S^2', structure='topological')
+ U = S2.open_subset('U'); V = S2.open_subset('V'); S2.declare_union(U,V)
+ c_xy = U.chart('x y'); x, y = c_xy[:]
+ c_uv = V.chart('u v'); u, v = c_uv[:]
+ xy_to_uv = c_xy.transition_map(c_uv, (x/(x**2+y**2), y/(x**2+y**2)), \
+ intersection_name='W', restrictions1= x**2+y**2!=0, \
+ restrictions2= u**2+v**2!=0)
+ uv_to_xy = xy_to_uv.inverse()
+ c_uvW = c_uv.restrict(U.intersection(V))
+ gSN1 = c_uvW.plot(c_xy, ranges={u:[-6.,-0.02], v:[-6.,-0.02]})
+ gSN2 = c_uvW.plot(c_xy, ranges={u:[-6.,-0.02], v:[0.02,6.]})
+ gSN3 = c_uvW.plot(c_xy, ranges={u:[0.02,6.], v:[-6.,-0.02]})
+ gSN4 = c_uvW.plot(c_xy, ranges={u:[0.02,6.], v:[0.02,6.]})
+ g = gSN1+gSN2+gSN3+gSN4; g.set_axes_range(-1.5, 1.5, -1.5, 1.5)
+ sphinx_plot(g)
+
+ The coordinate line u=1 (red) and the coordinate line v=1 (green) on
+ the same plot::
+
+ sage: gu1 = c_uvW.plot(c_xy, fixed_coords={u: 1}, max_range=20, plot_points=300)
+ sage: gv1 = c_uvW.plot(c_xy, fixed_coords={v: 1}, max_range=20, plot_points=300, color='green')
+ sage: show(gu1+gv1)
+
+ .. PLOT::
+
+ S2 = Manifold(2, 'S^2', structure='topological')
+ U = S2.open_subset('U'); V = S2.open_subset('V'); S2.declare_union(U,V)
+ c_xy = U.chart('x y'); x, y = c_xy[:]
+ c_uv = V.chart('u v'); u, v = c_uv[:]
+ xy_to_uv = c_xy.transition_map(c_uv, (x/(x**2+y**2), y/(x**2+y**2)), \
+ intersection_name='W', restrictions1= x**2+y**2!=0, \
+ restrictions2= u**2+v**2!=0)
+ uv_to_xy = xy_to_uv.inverse()
+ c_uvW = c_uv.restrict(U.intersection(V))
+ gu1 = c_uvW.plot(c_xy, fixed_coords={u: 1}, max_range=20, plot_points=300)
+ gv1 = c_uvW.plot(c_xy, fixed_coords={v: 1}, max_range=20, plot_points=300, color='green')
+ sphinx_plot(gu1+gv1)
+
+ Note that we have set ``max_range=20`` to have a wider range for the
+ coordinates u and v, i.e. to have [-20,20] instead of the default
+ [-8,8].
+
+ A 3-dimensional chart plotted in terms of itself results in a 3D
+ rectangular grid::
+
+ sage: g = c_cart.plot() # equivalent to c_cart.plot(c_cart)
+ sage: show(g) # a 3D mesh cube
+
+ A 4-dimensional chart plotted in terms of itself (the plot is
+ performed for at most 3 coordinates, which must be specified via
+ the argument ``ambient_coords``)::
+
+ sage: M = Manifold(4, 'M', structure='topological')
+ sage: X.<t,x,y,z> = M.chart()
+ sage: g = X.plot(ambient_coords=(t,x,y)) # the coordinate z is not depicted
+ sage: show(g) # a 3D mesh cube
+ sage: g = X.plot(ambient_coords=(t,y)) # the coordinates x and z are not depicted
+ sage: show(g) # a 2D mesh square
+
+ .. PLOT::
+
+ M = Manifold(4, 'M', structure='topological')
+ X = M.chart('t x y z'); t,x,y,z = X[:]
+ g = X.plot(ambient_coords=(t,y))
+ sphinx_plot(g)
+
+ """
+ from sage.misc.functional import numerical_approx
+ from sage.plot.graphics import Graphics
+ from sage.plot.line import line
+ from sage.manifolds.continuous_map import ContinuousMap
+ from utilities import set_axes_labels
+
+ def _plot_xx_list(xx_list, rem_coords, ranges, steps, nb_values):
+ r"""
+ Helper function to plot the coordinate grid.
+ """
+ coord = rem_coords[0]
+ xmin = ranges[coord][0]
+ sx = steps[coord]
+ resu = []
+ for xx in xx_list:
+ xc = xmin
+ for i in range(nb_values[coord]):
+ nxx = list(xx)
+ nxx[self._xx.index(coord)] = xc
+ resu.append(nxx)
+ xc += sx
+ if len(rem_coords) == 1:
+ return resu
+ else:
+ rem_coords.remove(coord)
+ return _plot_xx_list(resu, rem_coords, ranges, steps,
+ nb_values)
+
+ if chart is None:
+ chart = self
+ elif not isinstance(chart, Chart):
+ raise TypeError("the argument 'chart' must be a coordinate chart")
+ #
+ # 1/ Determination of the relation between self and chart
+ # ------------------------------------------------------------
+ nc = self._manifold.dimension()
+ if chart is self:
+ transf = self.multifunction(*(self._xx))
+ if nc > 3:
+ if ambient_coords is None:
+ raise TypeError("the argument 'ambient_coords' must be " +
+ "provided")
+ if len(ambient_coords) > 3:
+ raise ValueError("too many ambient coordinates")
+ fixed_coords = {}
+ for coord in self._xx:
+ if coord not in ambient_coords:
+ fixed_coords[coord] = 0
+ else:
+ transf = None # to be the MultiCoordFunction object relating self
+ # to the ambient chart
+ if mapping is None:
+ if not self._domain.is_subset(chart._domain):
+ raise ValueError("the domain of {} is not ".format(self) +
+ "included in that of {}".format(chart))
+ coord_changes = chart._domain._coord_changes
+ for chart_pair in coord_changes:
+ if chart_pair == (self, chart):
+ transf = coord_changes[chart_pair]._transf
+ break
+ else:
+ # Search for a subchart
+ for chart_pair in coord_changes:
+ for schart in chart._subcharts:
+ if chart_pair == (self, schart):
+ transf = coord_changes[chart_pair]._transf
+ else:
+ if not isinstance(mapping, ContinuousMap):
+ raise TypeError("the argument 'mapping' must be a " +
+ "continuous manifold map")
+ if not self._domain.is_subset(mapping._domain):
+ raise ValueError("the domain of {} is not ".format(self) +
+ "included in that of {}".format(mapping))
+ if not chart._domain.is_subset(mapping._codomain):
+ raise ValueError("the domain of {} is not ".format(chart) +
+ "included in the codomain of {}".format(
+ mapping))
+ try:
+ transf = mapping.coord_functions(chart1=self, chart2=chart)
+ except ValueError:
+ pass
+ if transf is None:
+ raise ValueError("no relation has been found between " +
+ "{} and {}".format(self, chart))
+ #
+ # 2/ Treatment of input parameters
+ # -----------------------------
+ if fixed_coords is None:
+ coords = self._xx
+ else:
+ fixed_coord_list = fixed_coords.keys()
+ coords = []
+ for coord in self._xx:
+ if coord not in fixed_coord_list:
+ coords.append(coord)
+ coords = tuple(coords)
+ if ambient_coords is None:
+ ambient_coords = chart._xx
+ elif not isinstance(ambient_coords, tuple):
+ ambient_coords = tuple(ambient_coords)
+ nca = len(ambient_coords)
+ if nca != 2 and nca !=3:
+ raise ValueError("bad number of ambient coordinates: {}".format(nca))
+ if ranges is None:
+ ranges = {}
+ ranges0 = {}
+ for coord in coords:
+ if coord in ranges:
+ ranges0[coord] = (numerical_approx(ranges[coord][0]),
+ numerical_approx(ranges[coord][1]))
+ else:
+ bounds = self._bounds[self._xx.index(coord)]
+ if bounds[0][0] == -Infinity:
+ xmin = numerical_approx(-max_range)
+ elif bounds[0][1]:
+ xmin = numerical_approx(bounds[0][0])
+ else:
+ xmin = numerical_approx(bounds[0][0] + 1.e-3)
+ if bounds[1][0] == Infinity:
+ xmax = numerical_approx(max_range)
+ elif bounds[1][1]:
+ xmax = numerical_approx(bounds[1][0])
+ else:
+ xmax = numerical_approx(bounds[1][0] - 1.e-3)
+ ranges0[coord] = (xmin, xmax)
+ ranges = ranges0
+ if nb_values is None:
+ if nca == 2: # 2D plot
+ nb_values = 9
+ else: # 3D plot
+ nb_values = 5
+ if not isinstance(nb_values, dict):
+ nb_values0 = {}
+ for coord in coords:
+ nb_values0[coord] = nb_values
+ nb_values = nb_values0
+ if steps is None:
+ steps = {}
+ for coord in coords:
+ if coord not in steps:
+ steps[coord] = (ranges[coord][1] - ranges[coord][0])/ \
+ (nb_values[coord]-1)
+ else:
+ nb_values[coord] = 1 + int(
+ (ranges[coord][1] - ranges[coord][0])/ steps[coord])
+ if not isinstance(color, dict):
+ color0 = {}
+ for coord in coords:
+ color0[coord] = color
+ color = color0
+ if not isinstance(style, dict):
+ style0 = {}
+ for coord in coords:
+ style0[coord] = style
+ style = style0
+ if not isinstance(thickness, dict):
+ thickness0 = {}
+ for coord in coords:
+ thickness0[coord] = thickness
+ thickness = thickness0
+ if not isinstance(plot_points, dict):
+ plot_points0 = {}
+ for coord in coords:
+ plot_points0[coord] = plot_points
+ plot_points = plot_points0
+ #
+ # 3/ Plots
+ # -----
+ xx0 = [0] * nc
+ if fixed_coords is not None:
+ if len(fixed_coords) != nc - len(coords):
+ raise ValueError("bad number of fixed coordinates")
+ for fc, val in fixed_coords.iteritems():
+ xx0[self._xx.index(fc)] = val
+ ind_a = [chart._xx.index(ac) for ac in ambient_coords]
+ resu = Graphics()
+ for coord in coords:
+ color_c, style_c = color[coord], style[coord]
+ thickness_c = thickness[coord]
+ rem_coords = list(coords)
+ rem_coords.remove(coord)
+ xx_list = [xx0]
+ if len(rem_coords) >= 1:
+ xx_list = _plot_xx_list(xx_list, rem_coords, ranges, steps,
+ nb_values)
+ xmin, xmax = ranges[coord]
+ nbp = plot_points[coord]
+ dx = (xmax - xmin) / (nbp-1)
+ ind_coord = self._xx.index(coord)
+ for xx in xx_list:
+ curve = []
+ first_invalid = False # initialization
+ xc = xmin
+ xp = list(xx)
+ if parameters is None:
+ for i in range(nbp):
+ xp[ind_coord] = xc
+ if self.valid_coordinates(*xp, tolerance=1e-13):
+ yp = transf(*xp, simplify=False)
+ curve.append( [numerical_approx(yp[j])
+ for j in ind_a] )
+ first_invalid = True # next invalid point will be
+ # the first one
+ else:
+ if first_invalid:
+ # the curve is stopped at previous point and
+ # added to the graph:
+ resu += line(curve, color=color_c,
+ linestyle=style_c,
+ thickness=thickness_c)
+ curve = [] # a new curve will start at the
+ # next valid point
+ first_invalid = False # next invalid point will not
+ # be the first one
+ xc += dx
+ else:
+ for i in range(nbp):
+ xp[ind_coord] = xc
+ if self.valid_coordinates(*xp, tolerance=1e-13,
+ parameters=parameters):
+ yp = transf(*xp, simplify=False)
+ curve.append(
+ [numerical_approx( yp[j].substitute(parameters) )
+ for j in ind_a] )
+ first_invalid = True # next invalid point will be
+ # the first one
+ else:
+ if first_invalid:
+ # the curve is stopped at previous point and
+ # added to the graph:
+ resu += line(curve, color=color_c,
+ linestyle=style_c,
+ thickness=thickness_c)
+ curve = [] # a new curve will start at the
+ # next valid point
+ first_invalid = False # next invalid point will not
+ # be the first one
+ xc += dx
+ if curve != []:
+ resu += line(curve, color=color_c,
+ linestyle=style_c,
+ thickness=thickness_c)
+ if nca==2: # 2D graphic
+ resu.set_aspect_ratio(1)
+ if label_axes:
+ # We update the dictionary _extra_kwds (options to be passed
+ # to show()), instead of using the method
+ # Graphics.axes_labels() since the latter is not robust w.r.t.
+ # graph addition
+ resu._extra_kwds['axes_labels'] = [r'$'+latex(ac)+r'$'
+ for ac in ambient_coords]
+ else: # 3D graphic
+ resu.aspect_ratio(1)
+ if label_axes:
+ labels = [str(ac) for ac in ambient_coords]
+ resu = set_axes_labels(resu, *labels)
+ return resu
#*****************************************************************************
@@ -1669,10 +2483,9 @@ class CoordChange(SageObject):
+ "must be provided")
self._chart1 = chart1
self._chart2 = chart2
- #*# when MultiCoordFunction will be implemented (trac #18640):
- # self._transf = chart1.multifunction(*transformations)
- #*# for now:
- self._transf = transformations
+ # The coordinate transformations are implemented via the class
+ # MultiCoordFunction:
+ self._transf = chart1.multifunction(*transformations)
self._inverse = None
# If the two charts are on the same open subset, the coordinate change
# is added to the subset (and supersets) dictionary:
@@ -1791,12 +2604,7 @@ class CoordChange(SageObject):
(3, -1)
"""
- #*# When MultiCoordFunction is implemented (trac #18640):
- # return self._transf(*coords)
- #*# for now:
- substitutions = {self._chart1._xx[j]: coords[j] for j in range(self._n1)}
- return tuple([self._transf[i].subs(substitutions).simplify_full()
- for i in range(self._n2)])
+ return self._transf(*coords)
def inverse(self):
r"""
@@ -1832,6 +2640,8 @@ class CoordChange(SageObject):
"""
from sage.symbolic.relation import solve
+ from sage.manifolds.utilities import simplify_chain_real, \
+ simplify_chain_generic
if self._inverse is not None:
return self._inverse
# The computation is necessary:
@@ -1857,10 +2667,7 @@ class CoordChange(SageObject):
coord_domain[i] = 'positive'
xp2 = [ SR.var('xxxx' + str(i), domain=coord_domain[i])
for i in range(n2) ]
- #*# when MultiCoordFunction will be implemented (trac #18640):
- # xx2 = self._transf.expr()
- #*# for now:
- xx2 = self._transf
+ xx2 = self._transf.expr()
equations = [xp2[i] == xx2[i] for i in range(n2)]
try:
solutions = solve(equations, *x1, solution_dict=True)
@@ -1871,6 +2678,14 @@ class CoordChange(SageObject):
if len(solutions) == 1:
x2_to_x1 = [solutions[0][x1[i]].subs(substitutions)
for i in range(n1)]
+ for transf in x2_to_x1:
+ try:
+ if self._domain.base_field_type() == 'real':
+ transf = simplify_chain_real(transf)
+ else:
+ transf = simplify_chain_generic(transf)
+ except AttributeError:
+ pass
else:
list_x2_to_x1 = []
for sol in solutions:
@@ -1879,14 +2694,22 @@ class CoordChange(SageObject):
"set_inverse() to set the inverse " +
"manually")
x2_to_x1 = [sol[x1[i]].subs(substitutions) for i in range(n1)]
+ for transf in x2_to_x1:
+ try:
+ if self._domain.base_field_type() == 'real':
+ transf = simplify_chain_real(transf)
+ else:
+ transf = simplify_chain_generic(transf)
+ except AttributeError:
+ pass
if self._chart1.valid_coordinates(*x2_to_x1):
list_x2_to_x1.append(x2_to_x1)
if len(list_x2_to_x1) == 0:
raise ValueError("no solution found; use set_inverse() to " +
"set the inverse manually")
if len(list_x2_to_x1) > 1:
- print "Multiple solutions found: "
- print list_x2_to_x1
+ print("Multiple solutions found: ")
+ print(list_x2_to_x1)
raise ValueError(
"non-unique solution to the inverse coordinate " +
"transformation; use set_inverse() to set the inverse " +
@@ -1938,7 +2761,7 @@ class CoordChange(SageObject):
sage: spher_to_cart.set_inverse(sqrt(x^3+y^2), atan2(y,x), verbose=True)
Check of the inverse coordinate transformation:
- r == sqrt(r^3*cos(ph)^3 + r^2*sin(ph)^2)
+ r == sqrt(r*cos(ph)^3 + sin(ph)^2)*r
ph == arctan2(r*sin(ph), r*cos(ph))
x == sqrt(x^3 + y^2)*x/sqrt(x^2 + y^2)
y == sqrt(x^3 + y^2)*y/sqrt(x^2 + y^2)
@@ -1992,10 +2815,7 @@ class CoordChange(SageObject):
raise ValueError("composition not possible: " +
"{} is different from {}".format(other._chart2,
other._chart1))
- #*# when MultiCoordFunction will be implemented (trac #18640):
- # transf = self._transf(*(other._transf.expr()))
- #*# for now:
- transf = self(*(other._transf))
+ transf = self._transf(*(other._transf.expr()))
return type(self)(other._chart1, self._chart2, *transf)
def restrict(self, dom1, dom2=None):
@@ -2038,12 +2858,8 @@ class CoordChange(SageObject):
ch2 = self._chart2.restrict(dom2)
if (ch1, ch2) in dom1.coord_changes():
return dom1.coord_changes()[(ch1,ch2)]
- #*# when MultiCoordFunction will be implemented (trac #18640):
- # return type(self)(self._chart1.restrict(dom1),
- # self._chart2.restrict(dom2), *(self._transf.expr()))
- #*# for now:
return type(self)(self._chart1.restrict(dom1),
- self._chart2.restrict(dom2), *(self._transf))
+ self._chart2.restrict(dom2), *(self._transf.expr()))
def display(self):
r"""
@@ -2079,10 +2895,7 @@ class CoordChange(SageObject):
from sage.tensor.modules.format_utilities import FormattedExpansion
coords2 = self._chart2[:]
n2 = len(coords2)
- #*# when MultiCoordFunction will be implemented (trac #18640):
- # expr = self._transf.expr()
- #*# for now:
- expr = self._transf
+ expr = self._transf.expr()
rtxt = ""
if n2 == 1:
rlatex = r"\begin{array}{lcl}"
diff --git a/src/sage/manifolds/continuous_map.py b/src/sage/manifolds/continuous_map.py
new file mode 100644
index 0000000..149041f
--- /dev/null
+++ b/src/sage/manifolds/continuous_map.py
@@ -0,0 +1,1830 @@
+r"""
+Continuous Maps between Topological Manifolds
+
+The class :class:`ContinuousMap` implements continuous maps from a topological
+manifold `M` to some topological manifold `N` over the same topological field
+`K` as `M`.
+
+AUTHORS:
+
+- Eric Gourgoulhon, Michal Bejger (2013-2015): initial version
+
+REFERENCES:
+
+- Chap. 1 of [KN63]_ \S. Kobayashi & K. Nomizu : *Foundations of Differential
+ Geometry*, vol. 1, Interscience Publishers (New York) (1963)
+- [Lee11]_ \J.M. Lee : *Introduction to Topological Manifolds*, 2nd ed.,
+ Springer (New York) (2011)
+
+"""
+
+#*****************************************************************************
+# 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.categories.homset import Hom
+from sage.categories.morphism import Morphism
+
+class ContinuousMap(Morphism):
+ r"""
+ Continuous map between two topological manifolds.
+
+ This class implements continuous maps of the type
+
+ .. MATH::
+
+ \Phi: M \longrightarrow N
+
+ where `M` and `N` are topological manifolds over the same topological
+ field `K`.
+
+ Continuous maps are the *morphisms* of the *category* of topological
+ manifolds. The set of all continuous maps from `M` to `N` is therefore the
+ homset between `M` and `N`, which is denoted by `\mathrm{Hom}(M,N)`.
+
+ The class :class:`ContinuousMap` is a Sage *element* class, whose *parent*
+ class is :class:`~sage.manifolds.manifold_homset.TopologicalManifoldHomset`.
+
+ INPUT:
+
+ - ``parent`` -- homset `\mathrm{Hom}(M,N)` to which the continuous
+ map belongs
+ - ``coord_functions`` -- (default: ``None``) if not ``None``, must be
+ a dictionary of the coordinate expressions (as lists (or tuples) of the
+ coordinates of the image expressed in terms of the coordinates of
+ the considered point) with the pairs of charts (chart1, chart2)
+ as keys (chart1 being a chart on `M` and chart2 a chart on `N`).
+ If the dimension of the map's codomain is 1, a single coordinate
+ expression can be passed instead of a tuple with a single element
+ - ``name`` -- (default: ``None``) name given to the continuous map
+ - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the
+ continuous map; if ``None``, the LaTeX symbol is set to
+ ``name``
+ - ``is_isomorphism`` -- (default: ``False``) determines whether the
+ constructed object is a isomorphism (i.e. a homeomorphism); if set to
+ ``True``, then the manifolds `M` and `N` must have the same dimension.
+ - ``is_identity`` -- (default: ``False``) determines whether the
+ constructed object is the identity map; if set to ``True``,
+ then `N` must be `M` and the entry ``coord_functions`` is not used.
+
+ .. NOTE::
+
+ If the information passed by means of the argument ``coord_functions``
+ is not sufficient to fully specify the continuous map,
+ further coordinate expressions, in other charts, can be subsequently
+ added by means of the method :meth:`add_expr`
+
+ EXAMPLES:
+
+ The standard embedding of the sphere `S^2` into `\RR^3`::
+
+ sage: M = Manifold(2, 'S^2', structure='topological') # the 2-dimensional sphere S^2
+ sage: U = M.open_subset('U') # complement of the North pole
+ sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+ sage: V = M.open_subset('V') # complement of the South pole
+ sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+ sage: M.declare_union(U,V) # S^2 is the union of U and V
+ sage: xy_to_uv = c_xy.transition_map(c_uv, (x/(x^2+y^2), y/(x^2+y^2)),
+ ....: intersection_name='W', restrictions1= x^2+y^2!=0,
+ ....: restrictions2= u^2+v^2!=0)
+ sage: uv_to_xy = xy_to_uv.inverse()
+ sage: N = Manifold(3, 'R^3', latex_name=r'\RR^3', structure='topological') # R^3
+ sage: c_cart.<X,Y,Z> = N.chart() # Cartesian coordinates on R^3
+ sage: Phi = M.continuous_map(N,
+ ....: {(c_xy, c_cart): [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)],
+ ....: (c_uv, c_cart): [2*u/(1+u^2+v^2), 2*v/(1+u^2+v^2), (1-u^2-v^2)/(1+u^2+v^2)]},
+ ....: name='Phi', latex_name=r'\Phi')
+ sage: Phi
+ Continuous map Phi from the 2-dimensional topological manifold S^2 to
+ the 3-dimensional topological manifold R^3
+ sage: Phi.parent()
+ Set of Morphisms from 2-dimensional topological manifold S^2 to
+ 3-dimensional topological manifold R^3 in Category of manifolds over
+ Real Field with 53 bits of precision
+ sage: Phi.parent() is Hom(M, N)
+ True
+ sage: type(Phi)
+ <class 'sage.manifolds.continuous_map.TopologicalManifoldHomset_with_category.element_class'>
+ sage: Phi.display()
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ It is possible to create the map via the method
+ :meth:`~sage.manifolds.manifold.TopologicalManifold.continuous_map`
+ only in a single pair of charts: the argument ``coord_functions`` is then
+ a mere list of coordinate expressions (and not a dictionary) and the
+ arguments ``chart1`` and ``chart2`` have to be provided if the charts
+ differ from the default ones on the domain and/or the codomain::
+
+ sage: Phi1 = M.continuous_map(N, [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)], \
+ ....: chart1=c_xy, chart2=c_cart, name='Phi', latex_name=r'\Phi')
+
+ Since c_xy and c_cart are the default charts on respectively ``M`` and
+ ``N``, they can be omitted, so that the above declaration is equivalent
+ to::
+
+ sage: Phi1 = M.continuous_map(N, [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)], \
+ ....: name='Phi', latex_name=r'\Phi')
+
+ With such a declaration, the continuous map is only partially defined
+ on the manifold `S^2`, being known in only one chart::
+
+ sage: Phi1.display()
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+
+ The definition can be completed by means of the method :meth:`add_expr`::
+
+ sage: Phi1.add_expr(c_uv, c_cart, [2*u/(1+u^2+v^2), 2*v/(1+u^2+v^2), (1-u^2-v^2)/(1+u^2+v^2)])
+ sage: Phi1.display()
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ At this stage, ``Phi1`` and ``Phi`` are fully equivalent::
+
+ sage: Phi1 == Phi
+ True
+
+ The test suite is passed::
+
+ sage: TestSuite(Phi).run()
+ sage: TestSuite(Phi1).run()
+
+ The map acts on points::
+
+ sage: np = M.point((0,0), chart=c_uv) # the North pole
+ sage: Phi(np)
+ Point on the 3-dimensional topological manifold R^3
+ sage: Phi(np).coord() # Cartesian coordinates
+ (0, 0, 1)
+ sage: sp = M.point((0,0), chart=c_xy) # the South pole
+ sage: Phi(sp).coord() # Cartesian coordinates
+ (0, 0, -1)
+
+ Continuous maps can be composed by means of the operator ``*``: let
+ us introduce the map `\RR^3\rightarrow \RR^2` corresponding to
+ the projection from the point `(X,Y,Z)=(0,0,1)` onto the equatorial plane
+ `Z=0`::
+
+ sage: P = Manifold(2, 'R^2', latex_name=r'\RR^2', structure='topological') # R^2 (equatorial plane)
+ sage: cP.<xP, yP> = P.chart()
+ sage: Psi = N.continuous_map(P, (X/(1-Z), Y/(1-Z)), name='Psi',
+ ....: latex_name=r'\Psi')
+ sage: Psi
+ Continuous map Psi from the 3-dimensional topological manifold R^3 to
+ the 2-dimensional topological manifold R^2
+ sage: Psi.display()
+ Psi: R^3 --> R^2
+ (X, Y, Z) |--> (xP, yP) = (-X/(Z - 1), -Y/(Z - 1))
+
+ Then we compose ``Psi`` with ``Phi``, thereby getting a map
+ `S^2\rightarrow \RR^2`::
+
+ sage: ster = Psi*Phi ; ster
+ Continuous map from the 2-dimensional topological manifold S^2 to the
+ 2-dimensional topological manifold R^2
+
+ Let us test on the South pole (``sp``) that ``ster`` is indeed the
+ composite of ``Psi`` and ``Phi``::
+
+ sage: ster(sp) == Psi(Phi(sp))
+ True
+
+ Actually ``ster`` is the stereographic projection from the North pole, as
+ its coordinate expression reveals::
+
+ sage: ster.display()
+ S^2 --> R^2
+ on U: (x, y) |--> (xP, yP) = (x, y)
+ on V: (u, v) |--> (xP, yP) = (u/(u^2 + v^2), v/(u^2 + v^2))
+
+ If its codomain is 1-dimensional, a continuous map must be
+ defined by a single symbolic expression for each pair of charts, and not
+ by a list/tuple with a single element::
+
+ sage: N = Manifold(1, 'N', structure='topological')
+ sage: c_N = N.chart('X')
+ sage: Phi = M.continuous_map(N, {(c_xy, c_N): x^2+y^2, \
+ ....: (c_uv, c_N): 1/(u^2+v^2)}) # not ...[1/(u^2+v^2)] or (1/(u^2+v^2),)
+
+ An example of continuous map `\RR \rightarrow \RR^2`::
+
+ sage: R = Manifold(1, 'R', structure='topological') # field R
+ sage: T.<t> = R.chart() # canonical chart on R
+ sage: R2 = Manifold(2, 'R^2', structure='topological') # R^2
+ sage: c_xy.<x,y> = R2.chart() # Cartesian coordinates on R^2
+ sage: Phi = R.continuous_map(R2, [cos(t), sin(t)], name='Phi') ; Phi
+ Continuous map Phi from the 1-dimensional topological manifold R to
+ the 2-dimensional topological manifold R^2
+ sage: Phi.parent()
+ Set of Morphisms from 1-dimensional topological manifold R to
+ 2-dimensional topological manifold R^2 in Category of manifolds over
+ Real Field with 53 bits of precision
+ sage: Phi.parent() is Hom(R, R2)
+ True
+ sage: Phi.display()
+ Phi: R --> R^2
+ t |--> (x, y) = (cos(t), sin(t))
+
+ An example of homeomorphism between the unit open disk and the Euclidean
+ plane `\RR^2`::
+
+ sage: D = R2.open_subset('D', coord_def={c_xy: x^2+y^2<1}) # the open unit disk
+ sage: Phi = D.homeomorphism(R2, [x/sqrt(1-x^2-y^2), y/sqrt(1-x^2-y^2)],
+ ....: name='Phi', latex_name=r'\Phi')
+ sage: Phi
+ Homeomorphism Phi from the Open subset D of the 2-dimensional
+ topological manifold R^2 to the 2-dimensional topological manifold R^2
+ sage: Phi.parent()
+ Set of Morphisms from Open subset D of the 2-dimensional topological
+ manifold R^2 to 2-dimensional topological manifold R^2 in Join of
+ Category of subobjects of sets and Category of manifolds over Real
+ Field with 53 bits of precision
+ sage: Phi.parent() is Hom(D, R2)
+ True
+ sage: Phi.display()
+ Phi: D --> R^2
+ (x, y) |--> (x, y) = (x/sqrt(-x^2 - y^2 + 1), y/sqrt(-x^2 - y^2 + 1))
+
+ The image of a point::
+
+ sage: p = D.point((1/2,0))
+ sage: q = Phi(p) ; q
+ Point on the 2-dimensional topological manifold R^2
+ sage: q.coord()
+ (1/3*sqrt(3), 0)
+
+ The inverse homeomorphism is computed by means of the method
+ :meth:`inverse`::
+
+ sage: Phi.inverse()
+ Homeomorphism Phi^(-1) from the 2-dimensional topological manifold R^2
+ to the Open subset D of the 2-dimensional topological manifold R^2
+ sage: Phi.inverse().display()
+ Phi^(-1): R^2 --> D
+ (x, y) |--> (x, y) = (x/sqrt(x^2 + y^2 + 1), y/sqrt(x^2 + y^2 + 1))
+
+ Equivalently, one may use the notations ``^(-1)`` or ``~`` to get the
+ inverse::
+
+ sage: Phi^(-1) is Phi.inverse()
+ True
+ sage: ~Phi is Phi.inverse()
+ True
+
+ Check that ``~Phi`` is indeed the inverse of ``Phi``::
+
+ sage: (~Phi)(q) == p
+ True
+ sage: Phi * ~Phi == R2.identity_map()
+ True
+ sage: ~Phi * Phi == D.identity_map()
+ True
+
+ The coordinate expression of the inverse homeomorphism::
+
+ sage: (~Phi).display()
+ Phi^(-1): R^2 --> D
+ (x, y) |--> (x, y) = (x/sqrt(x^2 + y^2 + 1), y/sqrt(x^2 + y^2 + 1))
+
+ A special case of homeomorphism: the identity map of the open unit disk::
+
+ sage: id = D.identity_map() ; id
+ Identity map Id_D of the Open subset D of the 2-dimensional topological
+ manifold R^2
+ sage: latex(id)
+ \mathrm{Id}_{D}
+ sage: id.parent()
+ Set of Morphisms from Open subset D of the 2-dimensional topological
+ manifold R^2 to Open subset D of the 2-dimensional topological
+ manifold R^2 in Join of Category of subobjects of sets and Category of
+ manifolds over Real Field with 53 bits of precision
+ sage: id.parent() is Hom(D, D)
+ True
+ sage: id is Hom(D,D).one() # the identity element of the monoid Hom(D,D)
+ True
+
+ The identity map acting on a point::
+
+ sage: id(p)
+ Point on the 2-dimensional topological manifold R^2
+ sage: id(p) == p
+ True
+ sage: id(p) is p
+ True
+
+ The coordinate expression of the identity map::
+
+ sage: id.display()
+ Id_D: D --> D
+ (x, y) |--> (x, y)
+
+ The identity map is its own inverse::
+
+ sage: id^(-1) is id
+ True
+ sage: ~id is id
+ True
+
+ """
+ def __init__(self, parent, coord_functions=None, name=None, latex_name=None,
+ is_isomorphism=False, is_identity=False):
+ r"""
+ Construct a continuous map.
+
+ TESTS::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: N = Manifold(3, 'N', structure='topological')
+ sage: Y.<u,v,w> = N.chart()
+ sage: f = Hom(M,N)({(X,Y): (x+y, x*y, x-y)}, name='f') ; f
+ Continuous map f from the 2-dimensional topological manifold M to
+ the 3-dimensional topological manifold N
+ sage: f.display()
+ f: M --> N
+ (x, y) |--> (u, v, w) = (x + y, x*y, x - y)
+ sage: TestSuite(f).run()
+
+ The identity map::
+
+ sage: f = Hom(M,M)({}, is_identity=True) ; f
+ Identity map Id_M of the 2-dimensional topological manifold M
+ sage: f.display()
+ Id_M: M --> M
+ (x, y) |--> (x, y)
+ sage: TestSuite(f).run()
+
+ """
+ Morphism.__init__(self, parent)
+ domain = parent.domain()
+ codomain = parent.codomain()
+ self._domain = domain
+ self._codomain = codomain
+ self._coord_expression = {} # dict. of coordinate expressions of the
+ # map:
+ # - key: pair of charts
+ # - value: instance of MultiCoordFunction
+ self._is_isomorphism = False # default value; may be redefined below
+ self._is_identity = False # default value; may be redefined below
+ if is_identity:
+ # Construction of the identity map
+ self._is_identity = True
+ self._is_isomorphism = True
+ if domain != codomain:
+ raise ValueError("the domain and codomain must coincide " + \
+ "for the identity map")
+ if name is None:
+ name = 'Id_' + domain._name
+ if latex_name is None:
+ latex_name = r'\mathrm{Id}_{' + domain._latex_name + r'}'
+ self._name = name
+ self._latex_name = latex_name
+ for chart in domain.atlas():
+ coord_funct = chart[:]
+ self._coord_expression[(chart, chart)] = chart.multifunction(
+ *coord_funct)
+ else:
+ # Construction of a generic continuous map
+ if is_isomorphism:
+ self._is_isomorphism = True
+ if domain.dim() != codomain.dim():
+ raise ValueError("for an isomorphism, the source " +
+ "manifold and target manifold must " +
+ "have the same dimension")
+ if coord_functions is not None:
+ n2 = self._codomain.dim()
+ for chart_pair, expression in coord_functions.iteritems():
+ if chart_pair[0] not in self._domain.atlas():
+ raise ValueError("{} is not a chart ".format(
+ chart_pair[0]) +
+ "defined on the {}".format(self._domain))
+ if chart_pair[1] not in self._codomain.atlas():
+ raise ValueError("{} is not a chart ".format(
+ chart_pair[1]) +
+ "defined on the {}".format(self._codomain))
+ if n2 == 1:
+ # a single expression entry is allowed (instead of a
+ # tuple)
+ if not isinstance(expression, (tuple, list)):
+ expression = (expression,)
+ if len(expression) != n2:
+ raise ValueError("{} coordinate ".format(n2) +
+ "functions must be provided")
+ self._coord_expression[chart_pair] = \
+ chart_pair[0].multifunction(*expression)
+ self._name = name
+ if latex_name is None:
+ self._latex_name = self._name
+ else:
+ self._latex_name = latex_name
+ self._init_derived() # initialization of derived quantities
+
+ #
+ # SageObject methods
+ #
+
+ def _repr_(self):
+ r"""
+ String representation of the object.
+
+ TESTS::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: f = Hom(M,N)({(X,Y): (x+y,x*y)})
+ sage: f._repr_()
+ 'Continuous map from the 2-dimensional topological manifold M to
+ the 2-dimensional topological manifold N'
+ sage: f = Hom(M,N)({(X,Y): (x+y,x*y)}, name='f')
+ sage: f._repr_()
+ 'Continuous map f from the 2-dimensional topological manifold M to
+ the 2-dimensional topological manifold N'
+ sage: f = Hom(M,N)({(X,Y): (x+y,x-y)}, name='f', is_isomorphism=True)
+ sage: f._repr_()
+ 'Homeomorphism f from the 2-dimensional topological manifold M to
+ the 2-dimensional topological manifold N'
+ sage: f = Hom(M,M)({(X,X): (x+y,x-y)}, name='f', is_isomorphism=True)
+ sage: f._repr_()
+ 'Homeomorphism f of the 2-dimensional topological manifold M'
+ sage: f = Hom(M,M)({}, name='f', is_identity=True)
+ sage: f._repr_()
+ 'Identity map f of the 2-dimensional topological manifold M'
+
+ """
+ if self._is_identity:
+ return "Identity map " + self._name + \
+ " of the {}".format(self._domain)
+ if self._is_isomorphism:
+ description = "Homeomorphism"
+ else:
+ description = "Continuous map"
+ if self._name is not None:
+ description += " " + self._name
+ if self._domain == self._codomain:
+ if self._is_isomorphism:
+ description += " of the {}".format(self._domain)
+ else:
+ description += " from the {} to itself".format(self._domain)
+ else:
+ description += " from the {} to the {}".format(self._domain,
+ self._codomain)
+ return description
+
+ def _latex_(self):
+ r"""
+ LaTeX representation of the object.
+
+ TESTS::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = Hom(M,M)({(X,X): (x+y,x*y)}, name='f')
+ sage: f._latex_()
+ 'f'
+ sage: f = Hom(M,M)({(X,X): (x+y,x*y)}, name='f', latex_name=r'\Phi')
+ sage: f._latex_()
+ '\\Phi'
+
+ """
+ if self._latex_name is None:
+ return r'\mbox{' + str(self) + r'}'
+ else:
+ return self._latex_name
+
+ def __eq__(self, other):
+ r"""
+ Comparison (equality) operator.
+
+ INPUT:
+
+ - ``other`` -- another instance of :class:`ContinuousMap` to compare
+ with
+
+ OUTPUT:
+
+ - True if ``self`` is equal to ``other``, or False otherwise
+
+ TESTS::
+
+ sage: M = Manifold(3, 'M', structure='topological')
+ sage: X.<x,y,z> = M.chart()
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: f = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='f')
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='g')
+ sage: f == g
+ True
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 1]}, name='g')
+ sage: f == g
+ False
+
+ """
+ if other is self:
+ return True
+ if not isinstance(other, type(self)):
+ return False
+ if self.parent() != other.parent():
+ return False
+ if self._is_identity:
+ return other.is_identity()
+ if other._is_identity:
+ return self.is_identity()
+ for charts, coord_functions in self._coord_expression.iteritems():
+ try:
+ if coord_functions.expr() != other.expr(*charts):
+ return False
+ except ValueError:
+ return False
+ return True
+
+ def __ne__(self, other):
+ r"""
+ Inequality operator.
+
+ INPUT:
+
+ - ``other`` -- another instance of :class:`ContinuousMap` to compare
+ with
+
+ OUTPUT:
+
+ - True if ``self`` is different from ``other``, or False otherwise
+
+ TESTS::
+
+ sage: M = Manifold(3, 'M', structure='topological')
+ sage: X.<x,y,z> = M.chart()
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: f = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='f')
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='g')
+ sage: f != g
+ False
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 1]}, name='g')
+ sage: f != g
+ True
+
+ """
+ return not (self == other)
+
+ def __cmp__(self, other):
+ r"""
+ Old-style (Python 2) comparison operator.
+
+ This is provisory, until migration to Python 3 is achieved.
+
+ TESTS::
+
+ sage: M = Manifold(3, 'M', structure='topological')
+ sage: X.<x,y,z> = M.chart()
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: f = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='f')
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 2*x*y*z]}, name='g')
+ sage: f.__cmp__(g)
+ 0
+ sage: g = M.continuous_map(N, {(X,Y): [x+y+z, 1]}, name='g')
+ sage: f.__cmp__(g)
+ -1
+
+ """
+ if self == other:
+ return 0
+ else:
+ return -1
+
+ #
+ # Map methods
+ #
+
+ def _call_(self, point):
+ r"""
+ Compute the image of a point by the continous map.
+
+ INPUT:
+
+ - ``point`` -- point in the domain of ``self``, as an instance of
+ :class:`~sage.manifolds.point.TopologicalManifoldPoint`
+
+ OUTPUT:
+
+ - image of the point by ``self`` (instance of
+ :class:`~sage.manifolds.point.TopologicalManifoldPoint`)
+
+ EXAMPLES:
+
+ Planar rotation acting on a point::
+
+ sage: M = Manifold(2, 'R^2', latex_name=r'\RR^2', structure='topological') # Euclidean plane
+ sage: c_cart.<x,y> = M.chart() # Cartesian coordinates
+ sage: # A pi/3 rotation around the origin defined in Cartesian coordinates:
+ sage: rot = M.continuous_map(M, ((x - sqrt(3)*y)/2, (sqrt(3)*x + y)/2),
+ ....: name='R')
+ sage: p = M.point((1,2), name='p')
+ sage: q = rot(p) ; q
+ Point R(p) on the 2-dimensional topological manifold R^2
+ sage: q.coord()
+ (-sqrt(3) + 1/2, 1/2*sqrt(3) + 1)
+
+ Image computed after some change of coordinates::
+
+ sage: c_spher.<r,ph> = M.chart(r'r:(0,+oo) ph:(0,2*pi):\phi') # spherical coord. on the plane
+ sage: ch = c_spher.transition_map(c_cart, [r*cos(ph), r*sin(ph)])
+ sage: p1 = M.point((sqrt(5), arctan(2)), chart=c_spher) # p1 is defined only in terms of c_spher
+ sage: q1 = rot(p1) # but the computation of the action of rot is still possible
+ sage: q1 == q
+ True
+
+ Image computed by means of spherical coordinates::
+
+ sage: rot.add_expr(c_spher, c_spher, (r, ph+pi/3)) # now rot is known in terms of c_spher
+ sage: p2 = M.point((sqrt(5), arctan(2)), chart=c_spher)
+ sage: q2 = rot(p2) # computation on c_spher
+ sage: q2 == q
+ True
+
+ """
+ # NB: checking that ``point`` belongs to the map's domain has been
+ # already performed by Map.__call__(); this check is therefore not
+ # repeated here.
+ if self._is_identity:
+ return point
+ dom = self._domain
+ chart1, chart2 = None, None
+ for chart in point._coordinates:
+ for chart_pair in self._coord_expression:
+ if chart_pair[0] is chart:
+ chart1 = chart
+ chart2 = chart_pair[1]
+ break
+ if chart1 is not None:
+ break
+ else:
+ # attempt to perform a change of coordinate on the point
+ for chart_pair in self._coord_expression:
+ try:
+ point.coord(chart_pair[0])
+ chart1, chart2 = chart_pair
+ except ValueError:
+ pass
+ if chart1 is not None:
+ break
+ else:
+ raise ValueError("no pair of charts has been found to " +
+ "compute the action of the {} on the {}".format(self, point))
+ coord_map = self._coord_expression[(chart1, chart2)]
+ y = coord_map(*(point._coordinates[chart1]))
+ if point._name is None or self._name is None:
+ res_name = None
+ else:
+ res_name = self._name + '(' + point._name + ')'
+ if point._latex_name is None or self._latex_name is None:
+ res_latex_name = None
+ else:
+ res_latex_name = self._latex_name + r'\left(' + \
+ point._latex_name + r'\right)'
+ # The image point is created as an element of the domain of chart2:
+ dom2 = chart2.domain()
+ return dom2.element_class(dom2, coords=y, chart=chart2,
+ name=res_name, latex_name=res_latex_name,
+ check_coords=False)
+ #
+ # Morphism methods
+ #
+
+ def is_identity(self):
+ r"""
+ Check whether the continuous map is an identity map.
+
+ EXAMPLES:
+
+ Tests on continuous maps of a 2-dimensional manifold::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: M.identity_map().is_identity() # obviously...
+ True
+ sage: Hom(M, M).one().is_identity() # a variant of the obvious
+ True
+ sage: a = M.continuous_map(M, coord_functions={(X,X): (x, y)})
+ sage: a.is_identity()
+ True
+ sage: a = M.continuous_map(M, coord_functions={(X,X): (x, y+1)})
+ sage: a.is_identity()
+ False
+
+ Of course, if the codomain of the map does not coincide with its
+ domain, the outcome is ``False``::
+
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: a = M.continuous_map(N, {(X,Y): (x, y)})
+ sage: a.display()
+ M --> N
+ (x, y) |--> (u, v) = (x, y)
+ sage: a.is_identity()
+ False
+
+ """
+ if self._is_identity:
+ return True
+ if self._codomain != self._domain:
+ return False
+ for chart in self._domain._top_charts:
+ try:
+ if chart[:] != self.expr(chart, chart):
+ return False
+ except ValueError:
+ return False
+ # If this point is reached, ``self`` must be the identity:
+ self._is_identity = True
+ return True
+
+ def _composition_(self, other, homset):
+ r"""
+ Composition of ``self`` with another morphism.
+
+ The composition is performed on the right, i.e. the returned
+ morphism is ``self*other``.
+
+ INPUT:
+
+ - ``other`` -- a continuous map, whose codomain is the domain
+ of ``self``
+ - ``homset`` -- the homset of the continuous map ``self*other``;
+ this argument is required to follow the prototype of
+ :meth:`~sage.categories.map.Map._composition_` and is determined by
+ :meth:`~sage.categories.map.Map._composition` (single underscore),
+ that is supposed to call the current method
+
+ OUTPUT:
+
+ - the composite map ``self*other``, as an instance of
+ :class:`~sage.manifolds.continuous_map.ContinuousMap`
+
+ TESTS::
+
+ sage: M = Manifold(3, 'M', structure='topological')
+ sage: X.<x,y,z> = M.chart()
+ sage: N = Manifold(2, 'N', structure='topological')
+ sage: Y.<u,v> = N.chart()
+ sage: Q = Manifold(4, 'Q', structure='topological')
+ sage: Z.<a,b,c,d> = Q.chart()
+ sage: f = N.continuous_map(Q, [u+v, u*v, 1+u, 2-v])
+ sage: g = M.continuous_map(N, [x+y+z, x*y*z])
+ sage: s = f._composition_(g, Hom(M,Q)); s
+ Continuous map from the 3-dimensional topological manifold M to the 4-dimensional topological manifold Q
+ sage: s.display()
+ M --> Q
+ (x, y, z) |--> (a, b, c, d) = ((x*y + 1)*z + x + y, x*y*z^2 + (x^2*y + x*y^2)*z, x + y + z + 1, -x*y*z + 2)
+ sage: s == f*g
+ True
+
+ """
+ # This method is invoked by Map._composition (single underscore),
+ # which is itself invoked by Map.__mul__ . The latter performs the
+ # check other._codomain == self._domain. There is therefore no need
+ # to perform it here.
+ if self._is_identity:
+ return other
+ if other._is_identity:
+ return self
+ resu_funct = {}
+ for chart1 in other._domain._top_charts:
+ for chart2 in self._domain._top_charts:
+ for chart3 in self._codomain._top_charts:
+ try:
+ self23 = self.coord_functions(chart2, chart3)
+ resu_funct[(chart1, chart3)] = \
+ self23(*(other.expr(chart1, chart2)),
+ simplify=True)
+ except ValueError:
+ pass
+ return homset(resu_funct)
+
+ #
+ # Monoid methods
+ #
+
+ def _mul_(self, other):
+ r"""
+ Composition of ``self`` with another morphism (endomorphism case).
+
+ This applies only when the parent of ``self`` is a monoid, i.e. when
+ ``self`` is an endomorphism of the category of topological manifolds,
+ i.e. a continuous map M --> M, where M is a topological manifold.
+
+ INPUT:
+
+ - ``other`` -- a continuous map, whose codomain is the domain
+ of ``self``
+
+ OUTPUT:
+
+ - the composite map ``self*other``, as an instance of
+ :class:`~sage.manifolds.continuous_map.ContinuousMap`
+
+ TESTS::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = M.continuous_map(M, [x+y, x*y], name='f')
+ sage: g = M.continuous_map(M, [1-y, 2+x], name='g')
+ sage: s = f._mul_(g); s
+ Continuous map from the 2-dimensional topological manifold M to
+ itself
+ sage: s.display()
+ M --> M
+ (x, y) |--> (x - y + 3, -(x + 2)*y + x + 2)
+ sage: s == f*g
+ True
+ sage: f._mul_(M.identity_map()) == f
+ True
+ sage: M.identity_map()._mul_(f) == f
+ True
+
+ """
+ from sage.categories.homset import Hom
+ dom = self._domain
+ return self._composition_(other, Hom(dom, dom))
+
+ #
+ # Other methods
+ #
+
+ def _init_derived(self):
+ r"""
+ Initialize the derived quantities
+
+ TEST::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = M.homeomorphism(M, [x+y, x-y])
+ sage: f._init_derived()
+ sage: f._restrictions
+ {}
+ sage: f._inverse
+
+ """
+ self._restrictions = {} # dict. of restrictions to subdomains of
+ # self._domain
+ if self._is_identity:
+ self._inverse = self
+ else:
+ self._inverse = None
+
+ def _del_derived(self):
+ r"""
+ Delete the derived quantities
+
+ TEST::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = M.homeomorphism(M, [x+y, x-y])
+ sage: f^(-1)
+ Homeomorphism of the 2-dimensional topological manifold M
+ sage: f._inverse # was set by f^(-1)
+ Homeomorphism of the 2-dimensional topological manifold M
+ sage: f._del_derived()
+ sage: f._inverse # has been set to None by _del_derived()
+
+ """
+ self._restrictions.clear()
+ if not self._is_identity:
+ self._inverse = None
+
+ def display(self, chart1=None, chart2=None):
+ r"""
+ Display the expression of the continuous map in one or more
+ pair of charts.
+
+ If the expression is not known already, it is computed from some
+ expression in other charts by means of change-of-coordinate formulas.
+
+ INPUT:
+
+ - ``chart1`` -- (default: ``None``) chart on the map's domain; if
+ ``None``, the display is performed on all the charts on the domain
+ in which the map is known or computable via some change of
+ coordinates
+ - ``chart2`` -- (default: ``None``) chart on the map's codomain; if
+ ``None``, the display is performed on all the charts on the codomain
+ in which the map is known or computable via some change of
+ coordinates
+
+ The output is either text-formatted (console mode) or LaTeX-formatted
+ (notebook mode).
+
+ EXAMPLES:
+
+ Standard embedding of the sphere `S^2` in `\RR^3`::
+
+ sage: M = Manifold(2, 'S^2', structure='topological') # the 2-dimensional sphere S^2
+ sage: U = M.open_subset('U') # complement of the North pole
+ sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+ sage: V = M.open_subset('V') # complement of the South pole
+ sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+ sage: M.declare_union(U,V) # S^2 is the union of U and V
+ sage: N = Manifold(3, 'R^3', latex_name=r'\RR^3', structure='topological') # R^3
+ sage: c_cart.<X,Y,Z> = N.chart() # Cartesian coordinates on R^3
+ sage: Phi = M.continuous_map(N, \
+ ....: {(c_xy, c_cart): [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)],
+ ....: (c_uv, c_cart): [2*u/(1+u^2+v^2), 2*v/(1+u^2+v^2), (1-u^2-v^2)/(1+u^2+v^2)]},
+ ....: name='Phi', latex_name=r'\Phi')
+ sage: Phi.display(c_xy, c_cart)
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ sage: Phi.display(c_uv, c_cart)
+ Phi: S^2 --> R^3
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ The LaTeX output::
+
+ sage: latex(Phi.display(c_xy, c_cart))
+ \begin{array}{llcl} \Phi:& S^2 & \longrightarrow & \RR^3 \\ \mbox{on}\ U : & \left(x, y\right) & \longmapsto & \left(X, Y, Z\right) = \left(\frac{2 \, x}{x^{2} + y^{2} + 1}, \frac{2 \, y}{x^{2} + y^{2} + 1}, \frac{x^{2} + y^{2} - 1}{x^{2} + y^{2} + 1}\right) \end{array}
+
+ If the argument ``chart2`` is not specified, the display is performed
+ on all the charts on the codomain in which the map is known
+ or computable via some change of coordinates (here only one chart:
+ c_cart)::
+
+ sage: Phi.display(c_xy)
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+
+ Similarly, if the argument ``chart1`` is omitted, the display is
+ performed on all the charts on the map's domain in which the
+ map is known or computable via some change of coordinates::
+
+ sage: Phi.display(chart2=c_cart)
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ If neither ``chart1`` nor ``chart2`` is specified, the display is
+ performed on all the pair of charts in which the map is known or
+ computable via some change of coordinates::
+
+ sage: Phi.display()
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ If a chart covers entirely the map's domain, the mention "on ..."
+ is omitted::
+
+ sage: Phi.restrict(U).display()
+ Phi: U --> R^3
+ (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+
+ A shortcut of ``display()`` is ``disp()``::
+
+ sage: Phi.disp()
+ Phi: S^2 --> R^3
+ on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
+ on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
+
+ """
+ from sage.misc.latex import latex
+ from sage.tensor.modules.format_utilities import FormattedExpansion
+
+ def _display_expression(self, chart1, chart2, result):
+ r"""
+ Helper function for :meth:`display`.
+ """
+ from sage.misc.latex import latex
+ try:
+ expression = self.expr(chart1, chart2)
+ coords1 = chart1[:]
+ if len(coords1) == 1:
+ coords1 = coords1[0]
+ coords2 = chart2[:]
+ if len(coords2) == 1:
+ coords2 = coords2[0]
+ if chart1._domain == self._domain:
+ result._txt += " "
+ result._latex += " & "
+ else:
+ result._txt += "on " + chart1._domain._name + ": "
+ result._latex += r"\mbox{on}\ " + latex(chart1._domain) + \
+ r": & "
+ result._txt += repr(coords1) + " |--> "
+ result._latex += latex(coords1) + r"& \longmapsto & "
+ if chart2 == chart1:
+ if len(expression) == 1:
+ result._txt += repr(expression[0]) + "\n"
+ result._latex += latex(expression[0]) + r"\\"
+ else:
+ result._txt += repr(expression) + "\n"
+ result._latex += latex(expression) + r"\\"
+ else:
+ if len(expression) == 1:
+ result._txt += repr(coords2[0]) + " = " + \
+ repr(expression[0]) + "\n"
+ result._latex += latex(coords2[0]) + " = " + \
+ latex(expression[0]) + r"\\"
+ else:
+ result._txt += repr(coords2) + " = " + \
+ repr(expression) + "\n"
+ result._latex += latex(coords2) + " = " + \
+ latex(expression) + r"\\"
+ except (TypeError, ValueError):
+ pass
+
+ result = FormattedExpansion()
+ if self._name is None:
+ symbol = ""
+ else:
+ symbol = self._name + ": "
+ result._txt = symbol + self._domain._name + " --> " + \
+ self._codomain._name + "\n"
+ if self._latex_name is None:
+ symbol = ""
+ else:
+ symbol = self._latex_name + ":"
+ result._latex = r"\begin{array}{llcl} " + symbol + r"&" + \
+ latex(self._domain) + r"& \longrightarrow & " + \
+ latex(self._codomain) + r"\\"
+ if chart1 is None:
+ if chart2 is None:
+ for ch1 in self._domain._top_charts:
+ for ch2 in self._codomain.atlas():
+ _display_expression(self, ch1, ch2, result)
+ else:
+ for ch1 in self._domain._top_charts:
+ _display_expression(self, ch1, chart2, result)
+ else:
+ if chart2 is None:
+ for ch2 in self._codomain.atlas():
+ _display_expression(self, chart1, ch2, result)
+ else:
+ _display_expression(self, chart1, chart2, result)
+ result._txt = result._txt[:-1]
+ result._latex = result._latex[:-2] + r"\end{array}"
+ return result
+
+ disp = display
+
+ def coord_functions(self, chart1=None, chart2=None):
+ r"""
+ Return the functions of the coordinates representing the continuous
+ map in a given pair of charts.
+
+ If these functions are not already known, they are computed from known
+ ones by means of change-of-chart formulas.
+
+ INPUT:
+
+ - ``chart1`` -- (default: ``None``) chart on the map's domain;
+ if ``None``, the domain's default chart is assumed
+ - ``chart2`` -- (default: ``None``) chart on the map's codomain;
+ if ``None``, the codomain's default chart is assumed
+
+ OUTPUT:
+
+ - instance of class
+ :class:`~sage.manifolds.coord_func.MultiCoordFunction`
+ representing the continuous map in the above two charts
+
+ EXAMPLES:
+
+ Continuous map from a 2-dimensional manifold to a 3-dimensional
+ one::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: N = Manifold(3, 'N', structure='topological')
+ sage: c_uv.<u,v> = M.chart()
+ sage: c_xyz.<x,y,z> = N.chart()
+ sage: Phi = M.continuous_map(N, (u*v, u/v, u+v), name='Phi',
+ ....: latex_name=r'\Phi')
+ sage: Phi.display()
+ Phi: M --> N
+ (u, v) |--> (x, y, z) = (u*v, u/v, u + v)
+ sage: Phi.coord_functions(c_uv, c_xyz)
+ Coordinate functions (u*v, u/v, u + v) on the Chart (M, (u, v))
+ sage: Phi.coord_functions() # equivalent to above since 'uv' and 'xyz' are default charts
+ Coordinate functions (u*v, u/v, u + v) on the Chart (M, (u, v))
+ sage: type(Phi.coord_functions())
+ <class 'sage.manifolds.coord_func.MultiCoordFunction'>
+
+ Coordinate representation in other charts::
+
+ sage: c_UV.<U,V> = M.chart() # new chart on M
+ sage: ch_uv_UV = c_uv.transition_map(c_UV, [u-v, u+v])
+ sage: ch_uv_UV.inverse()(U,V)
+ (1/2*U + 1/2*V, -1/2*U + 1/2*V)
+ sage: c_XYZ.<X,Y,Z> = N.chart() # new chart on N
+ sage: ch_xyz_XYZ = c_xyz.transition_map(c_XYZ,
+ ....: [2*x-3*y+z, y+z-x, -x+2*y-z])
+ sage: ch_xyz_XYZ.inverse()(X,Y,Z)
+ (3*X + Y + 4*Z, 2*X + Y + 3*Z, X + Y + Z)
+ sage: Phi.coord_functions(c_UV, c_xyz)
+ Coordinate functions (-1/4*U^2 + 1/4*V^2, -(U + V)/(U - V), V) on
+ the Chart (M, (U, V))
+ sage: Phi.coord_functions(c_uv, c_XYZ)
+ Coordinate functions (((2*u + 1)*v^2 + u*v - 3*u)/v,
+ -((u - 1)*v^2 - u*v - u)/v, -((u + 1)*v^2 + u*v - 2*u)/v) on the
+ Chart (M, (u, v))
+ sage: Phi.coord_functions(c_UV, c_XYZ)
+ Coordinate functions
+ (-1/2*(U^3 - (U - 2)*V^2 + V^3 - (U^2 + 2*U + 6)*V - 6*U)/(U - V),
+ 1/4*(U^3 - (U + 4)*V^2 + V^3 - (U^2 - 4*U + 4)*V - 4*U)/(U - V),
+ 1/4*(U^3 - (U - 4)*V^2 + V^3 - (U^2 + 4*U + 8)*V - 8*U)/(U - V))
+ on the Chart (M, (U, V))
+
+ Coordinate representation w.r.t. a subchart in the domain::
+
+ sage: A = M.open_subset('A', coord_def={c_uv: u>0})
+ sage: Phi.coord_functions(c_uv.restrict(A), c_xyz)
+ Coordinate functions (u*v, u/v, u + v) on the Chart (A, (u, v))
+
+ Coordinate representation w.r.t. a superchart in the codomain::
+
+ sage: B = N.open_subset('B', coord_def={c_xyz: x<0})
+ sage: c_xyz_B = c_xyz.restrict(B)
+ sage: Phi1 = M.continuous_map(B, {(c_uv, c_xyz_B): (u*v, u/v, u+v)})
+ sage: Phi1.coord_functions(c_uv, c_xyz_B) # definition charts
+ Coordinate functions (u*v, u/v, u + v) on the Chart (M, (u, v))
+ sage: Phi1.coord_functions(c_uv, c_xyz) # c_xyz = superchart of c_xyz_B
+ Coordinate functions (u*v, u/v, u + v) on the Chart (M, (u, v))
+
+ Coordinate representation w.r.t. a pair (subchart, superchart)::
+
+ sage: Phi1.coord_functions(c_uv.restrict(A), c_xyz)
+ Coordinate functions (u*v, u/v, u + v) on the Chart (A, (u, v))
+
+ """
+ dom1 = self._domain; dom2 = self._codomain
+ def_chart1 = dom1._def_chart; def_chart2 = dom2._def_chart
+ if chart1 is None:
+ chart1 = def_chart1
+ if chart2 is None:
+ chart2 = def_chart2
+ if (chart1, chart2) not in self._coord_expression:
+ # Check whether (chart1, chart2) are (subchart, superchart) of
+ # a pair of charts where the expression of self is known:
+ for (ochart1, ochart2) in self._coord_expression:
+ if chart1 in ochart1._subcharts and \
+ ochart2 in chart2._subcharts:
+ coord_functions = \
+ self._coord_expression[(ochart1, ochart2)].expr()
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(*coord_functions)
+ return self._coord_expression[(chart1, chart2)]
+ # Special case of the identity in a single chart:
+ if self._is_identity and chart1 == chart2:
+ coord_functions = chart1[:]
+ self._coord_expression[(chart1, chart1)] = \
+ chart1.multifunction(*coord_functions)
+ return self._coord_expression[(chart1, chart2)]
+ # Some change of coordinates must be performed
+ change_start = [] ; change_arrival = []
+ for (ochart1, ochart2) in self._coord_expression:
+ if chart1 == ochart1:
+ change_arrival.append(ochart2)
+ if chart2 == ochart2:
+ change_start.append(ochart1)
+ # 1/ Trying to make a change of chart only on the codomain:
+ # the codomain's default chart is privileged:
+ sel_chart2 = None # selected chart2
+ if def_chart2 in change_arrival \
+ and (def_chart2, chart2) in dom2._coord_changes:
+ sel_chart2 = def_chart2
+ else:
+ for ochart2 in change_arrival:
+ if (ochart2, chart2) in dom2._coord_changes:
+ sel_chart2 = ochart2
+ break
+ if sel_chart2 is not None:
+ oexpr = self._coord_expression[(chart1, sel_chart2)]
+ chg2 = dom2._coord_changes[(sel_chart2, chart2)]
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(*(chg2(*(oexpr.expr()))))
+ return self._coord_expression[(chart1, chart2)]
+
+ # 2/ Trying to make a change of chart only on the start domain:
+ # the domain's default chart is privileged:
+ sel_chart1 = None # selected chart1
+ if def_chart1 in change_start \
+ and (chart1, def_chart1) in dom1._coord_changes:
+ sel_chart1 = def_chart1
+ else:
+ for ochart1 in change_start:
+ if (chart1, ochart1) in dom1._coord_changes:
+ sel_chart1 = ochart1
+ break
+ if sel_chart1 is not None:
+ oexpr = self._coord_expression[(sel_chart1, chart2)]
+ chg1 = dom1._coord_changes[(chart1, sel_chart1)]
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(*(oexpr( *(chg1._transf.expr()) )))
+ return self._coord_expression[(chart1, chart2)]
+
+ # 3/ If this point is reached, it is necessary to perform some
+ # coordinate change both on the start domain and the arrival one
+ # the default charts are privileged:
+ if (def_chart1, def_chart2) in self._coord_expression \
+ and (chart1, def_chart1) in dom1._coord_changes \
+ and (def_chart2, chart2) in dom2._coord_changes:
+ sel_chart1 = def_chart1
+ sel_chart2 = def_chart2
+ else:
+ for (ochart1, ochart2) in self._coord_expression:
+ if (chart1, ochart1) in dom1._coord_changes \
+ and (ochart2, chart2) in dom2._coord_changes:
+ sel_chart1 = ochart1
+ sel_chart2 = ochart2
+ break
+ if (sel_chart1 is not None) and (sel_chart2 is not None):
+ oexpr = self._coord_expression[(sel_chart1, sel_chart2)]
+ chg1 = dom1._coord_changes[(chart1, sel_chart1)]
+ chg2 = dom2._coord_changes[(sel_chart2, chart2)]
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(
+ *(chg2( *(oexpr(*(chg1._transf.expr()))) )) )
+ return self._coord_expression[(chart1, chart2)]
+
+ # 4/ If this point is reached, the demanded value cannot be
+ # computed
+ raise ValueError("the expression of the map in the pair " +
+ "({}, {})".format(chart1, chart2) + " cannot " +
+ "be computed by means of known changes of charts")
+
+ return self._coord_expression[(chart1, chart2)]
+
+ def expr(self, chart1=None, chart2=None):
+ r"""
+ Return the expression of the continuous map in terms of
+ specified coordinates.
+
+ If the expression is not already known, it is computed from some known
+ expression by means of change-of-chart formulas.
+
+ INPUT:
+
+ - ``chart1`` -- (default: ``None``) chart on the map's domain;
+ if ``None``, the domain's default chart is assumed
+ - ``chart2`` -- (default: ``None``) chart on the map's codomain;
+ if ``None``, the codomain's default chart is assumed
+
+ OUTPUT:
+
+ - symbolic expression representing the continuous map in the
+ above two charts
+
+ EXAMPLES:
+
+ Continuous map from a 2-dimensional manifold to a 3-dimensional
+ one::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: N = Manifold(3, 'N', structure='topological')
+ sage: c_uv.<u,v> = M.chart()
+ sage: c_xyz.<x,y,z> = N.chart()
+ sage: Phi = M.continuous_map(N, (u*v, u/v, u+v), name='Phi',
+ ....: latex_name=r'\Phi')
+ sage: Phi.display()
+ Phi: M --> N
+ (u, v) |--> (x, y, z) = (u*v, u/v, u + v)
+ sage: Phi.expr(c_uv, c_xyz)
+ (u*v, u/v, u + v)
+ sage: Phi.expr() # equivalent to above since 'uv' and 'xyz' are default charts
+ (u*v, u/v, u + v)
+ sage: type(Phi.expr()[0])
+ <type 'sage.symbolic.expression.Expression'>
+
+ Expressions in other charts::
+
+ sage: c_UV.<U,V> = M.chart() # new chart on M
+ sage: ch_uv_UV = c_uv.transition_map(c_UV, [u-v, u+v])
+ sage: ch_uv_UV.inverse()(U,V)
+ (1/2*U + 1/2*V, -1/2*U + 1/2*V)
+ sage: c_XYZ.<X,Y,Z> = N.chart() # new chart on N
+ sage: ch_xyz_XYZ = c_xyz.transition_map(c_XYZ,
+ ....: [2*x-3*y+z, y+z-x, -x+2*y-z])
+ sage: ch_xyz_XYZ.inverse()(X,Y,Z)
+ (3*X + Y + 4*Z, 2*X + Y + 3*Z, X + Y + Z)
+ sage: Phi.expr(c_UV, c_xyz)
+ (-1/4*U^2 + 1/4*V^2, -(U + V)/(U - V), V)
+ sage: Phi.expr(c_uv, c_XYZ)
+ (((2*u + 1)*v^2 + u*v - 3*u)/v,
+ -((u - 1)*v^2 - u*v - u)/v,
+ -((u + 1)*v^2 + u*v - 2*u)/v)
+ sage: Phi.expr(c_UV, c_XYZ)
+ (-1/2*(U^3 - (U - 2)*V^2 + V^3 - (U^2 + 2*U + 6)*V - 6*U)/(U - V),
+ 1/4*(U^3 - (U + 4)*V^2 + V^3 - (U^2 - 4*U + 4)*V - 4*U)/(U - V),
+ 1/4*(U^3 - (U - 4)*V^2 + V^3 - (U^2 + 4*U + 8)*V - 8*U)/(U - V))
+
+ A rotation in some Euclidean plane::
+
+ sage: M = Manifold(2, 'M', structure='topological') # the plane (minus a segment to have global regular spherical coordinates)
+ sage: c_spher.<r,ph> = M.chart(r'r:(0,+oo) ph:(0,2*pi):\phi') # spherical coordinates on the plane
+ sage: rot = M.continuous_map(M, (r, ph+pi/3), name='R') # pi/3 rotation around r=0
+ sage: rot.expr()
+ (r, 1/3*pi + ph)
+
+ Expression of the rotation in terms of Cartesian coordinates::
+
+ sage: c_cart.<x,y> = M.chart() # Declaration of Cartesian coordinates
+ sage: ch_spher_cart = c_spher.transition_map(c_cart,
+ ....: [r*cos(ph), r*sin(ph)]) # relation to spherical coordinates
+ sage: ch_spher_cart.set_inverse(sqrt(x^2+y^2), atan2(y,x), verbose=True)
+ Check of the inverse coordinate transformation:
+ r == r
+ ph == arctan2(r*sin(ph), r*cos(ph))
+ x == x
+ y == y
+ sage: rot.expr(c_cart, c_cart)
+ (-1/2*sqrt(3)*y + 1/2*x, 1/2*sqrt(3)*x + 1/2*y)
+
+ """
+ return self.coord_functions(chart1, chart2).expr()
+
+ def set_expr(self, chart1, chart2, coord_functions):
+ r"""
+ Set a new coordinate representation of the continuous map.
+
+ The expressions with respect to other charts are deleted, in order to
+ avoid any inconsistency. To keep them, use :meth:`add_expr` instead.
+
+ INPUT:
+
+ - ``chart1`` -- chart for the coordinates on the map's domain
+ - ``chart2`` -- chart for the coordinates on the map's codomain
+ - ``coord_functions`` -- the coordinate symbolic expression of the
+ map in the above charts: list (or tuple) of the coordinates of
+ the image expressed in terms of the coordinates of the considered
+ point; if the dimension of the codomain is 1, a single
+ expression is expected (not a list with a single element)
+
+ EXAMPLES:
+
+ Polar representation of a planar rotation initally defined in
+ Cartesian coordinates::
+
+ sage: M = Manifold(2, 'R^2', latex_name=r'\RR^2', structure='topological') # the Euclidean plane R^2
+ sage: c_xy.<x,y> = M.chart() # Cartesian coordinate on R^2
+ sage: U = M.open_subset('U', coord_def={c_xy: (y!=0, x<0)}) # the complement of the segment y=0 and x>0
+ sage: c_cart = c_xy.restrict(U) # Cartesian coordinates on U
+ sage: c_spher.<r,ph> = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi') # spherical coordinates on U
+ sage: # Links between spherical coordinates and Cartesian ones:
+ sage: ch_cart_spher = c_cart.transition_map(c_spher,
+ ....: [sqrt(x*x+y*y), atan2(y,x)])
+ sage: ch_cart_spher.set_inverse(r*cos(ph), r*sin(ph), verbose=True)
+ Check of the inverse coordinate transformation:
+ x == x
+ y == y
+ r == r
+ ph == arctan2(r*sin(ph), r*cos(ph))
+ sage: rot = U.continuous_map(U, ((x - sqrt(3)*y)/2, (sqrt(3)*x + y)/2),
+ ....: name='R')
+ sage: rot.display(c_cart, c_cart)
+ R: U --> U
+ (x, y) |--> (-1/2*sqrt(3)*y + 1/2*x, 1/2*sqrt(3)*x + 1/2*y)
+
+ Let us use the method :meth:`set_expr` to set the
+ spherical-coordinate expression by hand::
+
+ sage: rot.set_expr(c_spher, c_spher, (r, ph+pi/3))
+ sage: rot.display(c_spher, c_spher)
+ R: U --> U
+ (r, ph) |--> (r, 1/3*pi + ph)
+
+ The expression in Cartesian coordinates has been erased::
+
+ sage: rot._coord_expression
+ {(Chart (U, (r, ph)),
+ Chart (U, (r, ph))): Coordinate functions (r, 1/3*pi + ph)
+ on the Chart (U, (r, ph))}
+
+ It is recovered (thanks to the known change of coordinates) by a call
+ to :meth:`display`::
+
+ sage: rot.display(c_cart, c_cart)
+ R: U --> U
+ (x, y) |--> (-1/2*sqrt(3)*y + 1/2*x, 1/2*sqrt(3)*x + 1/2*y)
+
+ sage: rot._coord_expression # random (dictionary output)
+ {(Chart (U, (x, y)),
+ Chart (U, (x, y))): Coordinate functions (-1/2*sqrt(3)*y + 1/2*x,
+ 1/2*sqrt(3)*x + 1/2*y) on the Chart (U, (x, y)),
+ (Chart (U, (r, ph)),
+ Chart (U, (r, ph))): Coordinate functions (r, 1/3*pi + ph)
+ on the Chart (U, (r, ph))}
+
+ """
+ if self._is_identity:
+ raise NotImplementedError("set_expr() must not be used for the " +
+ "identity map")
+ if chart1 not in self._domain.atlas():
+ raise ValueError("the {}".format(chart1) +
+ " has not been defined on the {}".format(self._domain))
+ if chart2 not in self._codomain.atlas():
+ raise ValueError("the {}".format(chart2) +
+ " has not been defined on the {}".format(self._codomain))
+ self._coord_expression.clear()
+ self._del_derived()
+ n2 = self._codomain.dim()
+ if n2 > 1:
+ if len(coord_functions) != n2:
+ raise ValueError("{} coordinate functions must ".format(n2) +
+ "be provided.")
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(*coord_functions)
+ else:
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(coord_functions)
+
+ def add_expr(self, chart1, chart2, coord_functions):
+ r"""
+ Set a new coordinate representation of the continuous map.
+
+ The previous expressions with respect to other charts are kept. To
+ clear them, use :meth:`set_expr` instead.
+
+ INPUT:
+
+ - ``chart1`` -- chart for the coordinates on the map's domain
+ - ``chart2`` -- chart for the coordinates on the map's codomain
+ - ``coord_functions`` -- the coordinate symbolic expression of the
+ map in the above charts: list (or tuple) of the coordinates of
+ the image expressed in terms of the coordinates of the considered
+ point; if the dimension of the codomain is 1, a single
+ expression is expected (not a list with a single element)
+
+ .. WARNING::
+
+ If the map has already expressions in other charts, it
+ is the user's responsibility to make sure that the expression
+ to be added is consistent with them.
+
+ EXAMPLES:
+
+ Polar representation of a planar rotation initally defined in
+ Cartesian coordinates::
+
+ sage: M = Manifold(2, 'R^2', latex_name=r'\RR^2', structure='topological') # the Euclidean plane R^2
+ sage: c_xy.<x,y> = M.chart() # Cartesian coordinate on R^2
+ sage: U = M.open_subset('U', coord_def={c_xy: (y!=0, x<0)}) # the complement of the segment y=0 and x>0
+ sage: c_cart = c_xy.restrict(U) # Cartesian coordinates on U
+ sage: c_spher.<r,ph> = U.chart(r'r:(0,+oo) ph:(0,2*pi):\phi') # spherical coordinates on U
+ sage: # Links between spherical coordinates and Cartesian ones:
+ sage: ch_cart_spher = c_cart.transition_map(c_spher, [sqrt(x*x+y*y), atan2(y,x)])
+ sage: ch_cart_spher.set_inverse(r*cos(ph), r*sin(ph), verbose=True)
+ Check of the inverse coordinate transformation:
+ x == x
+ y == y
+ r == r
+ ph == arctan2(r*sin(ph), r*cos(ph))
+ sage: rot = U.continuous_map(U, ((x - sqrt(3)*y)/2, (sqrt(3)*x + y)/2),
+ ....: name='R')
+ sage: rot.display(c_cart, c_cart)
+ R: U --> U
+ (x, y) |--> (-1/2*sqrt(3)*y + 1/2*x, 1/2*sqrt(3)*x + 1/2*y)
+
+ If we make Sage calculate the expression in terms of spherical
+ coordinates, via the method :meth:`display`, we notice some difficulties
+ in arctan2 simplifications::
+
+ sage: rot.display(c_spher, c_spher)
+ R: U --> U
+ (r, ph) |--> (r, arctan2(1/2*(sqrt(3)*cos(ph) + sin(ph))*r, -1/2*(sqrt(3)*sin(ph) - cos(ph))*r))
+
+ Therefore, we use the method :meth:`add_expr` to set the
+ spherical-coordinate expression by hand::
+
+ sage: rot.add_expr(c_spher, c_spher, (r, ph+pi/3))
+ sage: rot.display(c_spher, c_spher)
+ R: U --> U
+ (r, ph) |--> (r, 1/3*pi + ph)
+
+ The call to :meth:`add_expr` has not deleted the expression in
+ terms of Cartesian coordinates, as we can check by printing the
+ dictionary :attr:`_coord_expression`, which stores the various internal
+ representations of the continuous map::
+
+ sage: rot._coord_expression # random (dictionary output)
+ {(Chart (U, (x, y)),
+ Chart (U, (x, y))): Coordinate functions (-1/2*sqrt(3)*y + 1/2*x,
+ 1/2*sqrt(3)*x + 1/2*y) on the Chart (U, (x, y)),
+ (Chart (U, (r, ph)),
+ Chart (U, (r, ph))): Coordinate functions (r, 1/3*pi + ph)
+ on the Chart (U, (r, ph))}
+
+ If, on the contrary, we use :meth:`set_expr`, the expression in
+ Cartesian coordinates is lost::
+
+ sage: rot.set_expr(c_spher, c_spher, (r, ph+pi/3))
+ sage: rot._coord_expression
+ {(Chart (U, (r, ph)),
+ Chart (U, (r, ph))): Coordinate functions (r, 1/3*pi + ph)
+ on the Chart (U, (r, ph))}
+
+ It is recovered (thanks to the known change of coordinates) by a call
+ to :meth:`display`::
+
+ sage: rot.display(c_cart, c_cart)
+ R: U --> U
+ (x, y) |--> (-1/2*sqrt(3)*y + 1/2*x, 1/2*sqrt(3)*x + 1/2*y)
+
+ sage: rot._coord_expression # random (dictionary output)
+ {(Chart (U, (x, y)),
+ Chart (U, (x, y))): Coordinate functions (-1/2*sqrt(3)*y + 1/2*x,
+ 1/2*sqrt(3)*x + 1/2*y) on the Chart (U, (x, y)),
+ (Chart (U, (r, ph)),
+ Chart (U, (r, ph))): Coordinate functions (r, 1/3*pi + ph)
+ on the Chart (U, (r, ph))}
+
+ The rotation can be applied to a point by means of either coordinate
+ system::
+
+ sage: p = M.point((1,2)) # p defined by its Cartesian coord.
+ sage: q = rot(p) # q is computed by means of Cartesian coord.
+ sage: p1 = M.point((sqrt(5), arctan(2)), chart=c_spher) # p1 is defined only in terms of c_spher
+ sage: q1 = rot(p1) # computation by means of spherical coordinates
+ sage: q1 == q
+ True
+
+ """
+ if self._is_identity:
+ raise NotImplementedError("add_expr() must not be used for the " +
+ "identity map")
+ if chart1 not in self._domain.atlas():
+ raise ValueError("the {}".format(chart1) +
+ " has not been defined on the {}".format(self._domain))
+ if chart2 not in self._codomain.atlas():
+ raise ValueError("the {}".format(chart2) +
+ " has not been defined on the {}".format(self._codomain))
+ self._del_derived()
+ n2 = self._codomain.dim()
+ if n2 > 1:
+ if len(coord_functions) != n2:
+ raise ValueError("{} coordinate functions must ".format(n2) +
+ "be provided")
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(*coord_functions)
+ else:
+ self._coord_expression[(chart1, chart2)] = \
+ chart1.multifunction(coord_functions)
+
+ def restrict(self, subdomain, subcodomain=None):
+ r"""
+ Restriction of the continuous map to some open subset of its
+ domain of definition.
+
+ INPUT:
+
+ - ``subdomain`` -- an open subset of the domain of the continuous map
+ (must be an instance of
+ :class:`~sage.manifolds.manifold.TopologicalManifold`)
+ - ``subcodomain`` -- (default: ``None``) an open subset of the codomain
+ of the continuous map (must be an instance of
+ :class:`~sage.manifolds.manifold.TopologicalManifold`); if ``None``,
+ the codomain of the continuous map is assumed.
+
+ OUTPUT:
+
+ - the restriction of the continuous map to ``subdomain``, as an
+ instance of class :class:`ContinuousMap`
+
+ EXAMPLE:
+
+ Restriction to an annulus of a homeomorphism between the open unit
+ disk and `\RR^2`::
+
+ sage: M = Manifold(2, 'R^2', structure='topological') # R^2
+ sage: c_xy.<x,y> = M.chart() # Cartesian coord. on R^2
+ sage: D = M.open_subset('D', coord_def={c_xy: x^2+y^2<1}) # the open unit disk
+ sage: Phi = D.continuous_map(M, [x/sqrt(1-x^2-y^2), y/sqrt(1-x^2-y^2)],
+ ....: name='Phi', latex_name=r'\Phi')
+ sage: Phi.display()
+ Phi: D --> R^2
+ (x, y) |--> (x, y) = (x/sqrt(-x^2 - y^2 + 1), y/sqrt(-x^2 - y^2 + 1))
+ sage: c_xy_D = c_xy.restrict(D)
+ sage: U = D.open_subset('U', coord_def={c_xy_D: x^2+y^2>1/2}) # the annulus 1/2 < r < 1
+ sage: Phi.restrict(U)
+ Continuous map Phi from the Open subset U of the 2-dimensional
+ topological manifold R^2 to the 2-dimensional topological
+ manifold R^2
+ sage: Phi.restrict(U).parent()
+ Set of Morphisms from Open subset U of the 2-dimensional
+ topological manifold R^2 to 2-dimensional topological manifold R^2
+ in Join of Category of subobjects of sets and Category of
+ manifolds over Real Field with 53 bits of precision
+ sage: Phi.domain()
+ Open subset D of the 2-dimensional topological manifold R^2
+ sage: Phi.restrict(U).domain()
+ Open subset U of the 2-dimensional topological manifold R^2
+ sage: Phi.restrict(U).display()
+ Phi: U --> R^2
+ (x, y) |--> (x, y) = (x/sqrt(-x^2 - y^2 + 1), y/sqrt(-x^2 - y^2 + 1))
+
+ The result is cached::
+
+ sage: Phi.restrict(U) is Phi.restrict(U)
+ True
+
+ The restriction of the identity map::
+
+ sage: id = D.identity_map() ; id
+ Identity map Id_D of the Open subset D of the 2-dimensional
+ topological manifold R^2
+ sage: id.restrict(U)
+ Identity map Id_U of the Open subset U of the 2-dimensional
+ topological manifold R^2
+ sage: id.restrict(U) is U.identity_map()
+ True
+
+ The codomain can be restricted (i.e. made tighter)::
+
+ sage: Phi = D.continuous_map(M, [x/sqrt(1+x^2+y^2), y/sqrt(1+x^2+y^2)])
+ sage: Phi
+ Continuous map from the Open subset D of the 2-dimensional
+ topological manifold R^2 to the 2-dimensional topological manifold R^2
+ sage: Phi.restrict(D, subcodomain=D)
+ Continuous map from the Open subset D of the 2-dimensional
+ topological manifold R^2 to itself
+
+ """
+ from sage.categories.homset import Hom
+ if subcodomain is None:
+ if self._is_identity:
+ subcodomain = subdomain
+ else:
+ subcodomain = self._codomain
+ if subdomain == self._domain and subcodomain == self._codomain:
+ return self
+ if (subdomain, subcodomain) not in self._restrictions:
+ if not subdomain.is_subset(self._domain):
+ raise ValueError("the specified domain is not a subset " +
+ "of the domain of definition of the " +
+ "continuous map")
+ if not subcodomain.is_subset(self._codomain):
+ raise ValueError("the specified codomain is not a subset " +
+ "of the codomain of the continuous map")
+ # Special case of the identity map:
+ if self._is_identity:
+ self._restrictions[(subdomain, subcodomain)] = \
+ subdomain.identity_map()
+ return self._restrictions[(subdomain, subcodomain)]
+ # Generic case:
+ homset = Hom(subdomain, subcodomain)
+ resu = type(self)(homset, name=self._name,
+ latex_name=self._latex_name)
+ for charts in self._coord_expression:
+ for ch1 in charts[0]._subcharts:
+ if ch1._domain.is_subset(subdomain):
+ for ch2 in charts[1]._subcharts:
+ if ch2._domain.is_subset(subcodomain):
+ for sch2 in ch2._supercharts:
+ if (ch1, sch2) in resu._coord_expression:
+ break
+ else:
+ for sch2 in ch2._subcharts:
+ if (ch1, sch2) in resu._coord_expression:
+ del resu._coord_expression[(ch1,
+ sch2)]
+ coord_functions = \
+ self._coord_expression[charts].expr()
+ resu._coord_expression[(ch1, ch2)] = \
+ ch1.multifunction(*coord_functions)
+ self._restrictions[(subdomain, subcodomain)] = resu
+ return self._restrictions[(subdomain, subcodomain)]
+
+
+ def __invert__(self):
+ r"""
+ Return the inverse of the map whenever it is an isomorphism.
+
+ OUTPUT:
+
+ - the inverse isomorphism
+
+ EXAMPLES:
+
+ The inverse of a rotation in the Euclidean plane::
+
+ sage: M = Manifold(2, 'R^2', latex_name=r'\RR^2', structure='topological')
+ sage: c_cart.<x,y> = M.chart()
+ sage: # A pi/3 rotation around the origin:
+ sage: rot = M.homeomorphism(M, ((x - sqrt(3)*y)/2, (sqrt(3)*x + y)/2),
+ ....: name='R')
+ sage: rot.inverse()
+ Homeomorphism R^(-1) of the 2-dimensional topological manifold R^2
+ sage: rot.inverse().display()
+ R^(-1): R^2 --> R^2
+ (x, y) |--> (1/2*sqrt(3)*y + 1/2*x, -1/2*sqrt(3)*x + 1/2*y)
+
+ Checking that applying successively the homeomorphism and its
+ inverse results in the identity::
+
+ sage: (a, b) = var('a b')
+ sage: p = M.point((a,b)) # a generic point on M
+ sage: q = rot(p)
+ sage: p1 = rot.inverse()(q)
+ sage: p1 == p
+ True
+
+ The result is cached::
+
+ sage: rot.inverse() is rot.inverse()
+ True
+
+ The notations ``^(-1)`` or ``~`` can also be used for the inverse::
+
+ sage: rot^(-1) is rot.inverse()
+ True
+ sage: ~rot is rot.inverse()
+ True
+
+ An example with multiple charts: the equatorial symmetry on the
+ 2-sphere::
+
+ sage: M = Manifold(2, 'M', structure='topological') # the 2-dimensional sphere S^2
+ sage: U = M.open_subset('U') # complement of the North pole
+ sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+ sage: V = M.open_subset('V') # complement of the South pole
+ sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+ sage: M.declare_union(U,V) # S^2 is the union of U and V
+ sage: xy_to_uv = c_xy.transition_map(c_uv, (x/(x^2+y^2), y/(x^2+y^2)),
+ ....: intersection_name='W', restrictions1= x^2+y^2!=0,
+ ....: restrictions2= u^2+v^2!=0)
+ sage: uv_to_xy = xy_to_uv.inverse()
+ sage: s = M.homeomorphism(M, {(c_xy, c_uv): [x, y], (c_uv, c_xy): [u, v]},
+ ....: name='s')
+ sage: s.display()
+ s: M --> M
+ on U: (x, y) |--> (u, v) = (x, y)
+ on V: (u, v) |--> (x, y) = (u, v)
+ sage: si = s.inverse(); si
+ Homeomorphism s^(-1) of the 2-dimensional topological manifold M
+ sage: si.display()
+ s^(-1): M --> M
+ on U: (x, y) |--> (u, v) = (x, y)
+ on V: (u, v) |--> (x, y) = (u, v)
+
+ The equatorial symmetry is of course an involution::
+
+ sage: si == s
+ True
+
+ """
+ from sage.symbolic.ring import SR
+ from sage.symbolic.relation import solve
+ if self._inverse is not None:
+ return self._inverse
+ if not self._is_isomorphism:
+ raise ValueError("the {} is not an isomorphism".format(self))
+ coord_functions = {} # coordinate expressions of the result
+ for (chart1, chart2) in self._coord_expression:
+ coord_map = self._coord_expression[(chart1, chart2)]
+ n1 = len(chart1._xx)
+ n2 = len(chart2._xx)
+ # New symbolic variables (different from chart2._xx to allow for a
+ # correct solution even when chart2 = chart1):
+ x2 = [ SR.var('xxxx' + str(i)) for i in range(n2) ]
+ equations = [ x2[i] == coord_map._functions[i]._express
+ for i in range(n2) ]
+ solutions = solve(equations, chart1._xx, solution_dict=True)
+ if len(solutions) == 0:
+ raise ValueError("no solution found")
+ if len(solutions) > 1:
+ raise ValueError("non-unique solution found")
+ substitutions = dict(zip(x2, chart2._xx))
+ inv_functions = [solutions[0][chart1._xx[i]].subs(substitutions)
+ for i in range(n1)]
+ for i in range(n1):
+ x = inv_functions[i]
+ try:
+ inv_functions[i] = chart2._simplify(x)
+ except AttributeError:
+ pass
+ coord_functions[(chart2, chart1)] = inv_functions
+ if self._name is None:
+ name = None
+ else:
+ name = self._name + '^(-1)'
+ if self._latex_name is None:
+ latex_name = None
+ else:
+ latex_name = self._latex_name + r'^{-1}'
+ homset = Hom(self._codomain, self._domain)
+ self._inverse = type(self)(homset, coord_functions=coord_functions,
+ name=name, latex_name=latex_name,
+ is_isomorphism=True)
+ return self._inverse
+
+ inverse = __invert__
diff --git a/src/sage/manifolds/coord_func.py b/src/sage/manifolds/coord_func.py
new file mode 100644
index 0000000..5bb4712
--- /dev/null
+++ b/src/sage/manifolds/coord_func.py
@@ -0,0 +1,1451 @@
+r"""
+Coordinate Functions
+
+In the context of a topological manifold `M` over a topological field `K`,
+a *coordinate function* is a function from a chart codomain
+to `K`. In other words, a coordinate function is a `K`-valued function of
+the coordinates associated to some chart.
+
+More precisely, let `(U, \varphi)` be a chart on `M`, i.e. `U` is an open
+subset of `M` and `\varphi: U \to V \subset K^n` is a homeomorphism
+from `U` to an open subset `V` of `K^n`. A *coordinate function associated
+to the chart* `(U, \varphi)` is a function
+
+.. MATH::
+
+ \begin{array}{cccc}
+ f:& V\subset K^n & \longrightarrow & K \\
+ & (x^1, \ldots, x^n) & \longmapsto & f(x^1, \ldots, x^n)
+ \end{array}
+
+Coordinate functions are implemented by derived classes of the abstract base
+class :class:`CoordFunction`.
+
+The class :class:`MultiCoordFunction` implements `K^m`-valued functions of
+the coordinates of a chart, with `m` a positive integer.
+
+AUTHORS:
+
+- Eric Gourgoulhon, Michal Bejger (2013-2015) : initial version
+- Travis Scrimshaw (2016) : make :class:`CoordFunction` inheritate from
+ :class:`~sage.structure.element.AlgebraElement`
+
+"""
+#*****************************************************************************
+# Copyright (C) 2015 Eric Gourgoulhon <eric.gourgoulhon@obspm.fr>
+# Copyright (C) 2015 Michal Bejger <bejger@camk.edu.pl>
+# Copyright (C) 2016 Travis Scrimshaw <tscrimsh@umn.edu>
+#
+# 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.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+from sage.structure.element import AlgebraElement
+from sage.structure.sage_object import SageObject
+
+class CoordFunction(AlgebraElement):
+ r"""
+ Abstract base class for coordinate functions.
+
+ If `(U, \varphi)` is a chart on a topological manifold `M` of
+ dimension `n` over a topological field `K`, a *coordinate function*
+ associated to `(U, \varphi)` is a map `f: V \subset K^n \to K`, where
+ `V` is the codomain of `\varphi`. In other words, `f` is a `K`-valued
+ function of the coordinates associated to the chart `(U, \varphi)`.
+
+ The class :class:`CoordFunction` is an abstract one. Specific
+ coordinate functions must be implemented by derived classes, like
+ :class:`~sage.manifolds.coord_func_symb.CoordFunctionSymb` for
+ symbolic coordinate functions.
+
+ INPUT:
+
+ - ``parent`` -- the algebra of coordinate functions on a given chart
+
+ """
+ def __init__(self, parent):
+ r"""
+ Initialize ``self``.
+
+ TEST::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+
+ """
+ AlgebraElement.__init__(self, parent)
+ self._nc = len(parent._chart[:]) # number of coordinates
+
+ # ----------------------------------------------------------------
+ # Methods that do not need to be re-implemented by derived classes
+ # ----------------------------------------------------------------
+
+ def chart(self):
+ r"""
+ Return the chart with respect to which ``self`` is defined.
+
+ OUTPUT:
+
+ - a :class:`~sage.manifolds.chart.Chart`
+
+ EXAMPLE::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = X.function(1+x+y^2)
+ sage: f.chart()
+ Chart (M, (x, y))
+ sage: f.chart() is X
+ True
+
+ """
+ return self.parent()._chart
+
+ def scalar_field(self, name=None, latex_name=None):
+ r"""
+ Construct the scalar field that has ``self`` as
+ coordinate expression.
+
+ The domain of the scalar field is the open subset covered by the
+ chart on which ``self`` is defined.
+
+ INPUT:
+
+ - ``name`` -- (default: ``None``) name given to the scalar field
+ - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the
+ scalar field; if ``None``, the LaTeX symbol is set to ``name``
+
+ OUTPUT:
+
+ - a :class:`~sage.manifolds.scalarfield.ScalarField`
+
+ EXAMPLES:
+
+ Construction of a scalar field on a 2-dimensional manifold::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: c_xy.<x,y> = M.chart()
+ sage: fc = c_xy.function(x+2*y^3)
+ sage: f = fc.scalar_field() ; f
+ Scalar field on the 2-dimensional topological manifold M
+ sage: f.display()
+ M --> R
+ (x, y) |--> 2*y^3 + x
+ sage: f.coord_function(c_xy) is fc
+ True
+
+ """
+ alg = self.parent()._chart.domain().scalar_field_algebra()
+ return alg.element_class(alg, coord_expression={self.parent()._chart: self},
+ name=name, latex_name=latex_name)
+
+ # TODO: This should be abstract up to SageObject at some point - TCS
+ def __ne__(self, other):
+ r"""
+ Inequality operator.
+
+ INPUT:
+
+ - ``other`` -- a :class:`CoordFunction` or a value
+
+ OUTPUT:
+
+ - ``True`` if ``self`` is different from ``other``, or ``False``
+ otherwise
+
+ TESTS::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: f = X.function(x+y)
+ sage: g = X.function(x*y)
+ sage: f != g
+ True
+ sage: h = X.function(x+y)
+ sage: f != h
+ False
+
+ """
+ return not (self == other)
+
+ # --------------------------------------------
+ # Methods to be implemented by derived classes
+ # --------------------------------------------
+
+ @abstract_method
+ def _repr_(self):
+ r"""
+ String representation of the object.
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._repr_()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _repr_ at 0x...>
+ """
+
+ @abstract_method
+ def _latex_(self):
+ r"""
+ LaTeX representation of the object.
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._latex_()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _latex_ at 0x...>
+ """
+
+ @abstract_method
+ def display(self):
+ r"""
+ Display the function in arrow notation.
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.display()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method display at 0x...>
+ """
+
+ disp = display
+
+ @abstract_method
+ def expr(self):
+ r"""
+ Return some data that, along with the chart, is sufficient to
+ reconstruct the object.
+
+ For a symbolic coordinate function, this returns the symbol
+ expression representing the function (see
+ :meth:`sage.manifolds.coord_func_symb.CoordFunctionSymb.expr`)
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.expr()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method expr at 0x...>
+
+ """
+
+ @abstract_method
+ def __call__(self, *coords, **options):
+ r"""
+ Compute the value of the function at specified coordinates.
+
+ INPUT:
+
+ - ``*coords`` -- list of coordinates `(x^1, \ldots ,x^n)`,
+ where the function `f` is to be evaluated
+ - ``**options`` -- options to control the computation (e.g.
+ simplification options)
+
+ OUTPUT:
+
+ - the value `f(x^1, \ldots, x^n)`, where `f` is the current
+ coordinate function
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.__call__(2,-3)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method __call__ at 0x...>
+
+ """
+
+ @abstract_method
+ def is_zero(self):
+ r"""
+ Return ``True`` if the function is zero and ``False`` otherwise.
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.is_zero()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method is_zero at 0x...>
+
+ """
+
+ @abstract_method
+ def copy(self):
+ r"""
+ Return an exact copy of the object.
+
+ OUTPUT:
+
+ - an instance of :class:`CoordFunction`
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.copy()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method copy at 0x...>
+
+ """
+
+ @abstract_method
+ def diff(self, coord):
+ r"""
+ Return the partial derivative of ``self`` with respect to a
+ coordinate.
+
+ INPUT:
+
+ - ``coord`` -- either the coordinate `x^i` with respect
+ to which the derivative of the coordinate function `f` is to be
+ taken, or the index `i` labelling this coordinate (with the
+ index convention defined on the chart domain via the parameter
+ ``start_index``)
+
+ OUTPUT:
+
+ - instance of :class:`CoordFunction` representing the partial
+ derivative `\frac{\partial f}{\partial x^i}`
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.diff(x)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method diff at 0x...>
+
+ """
+
+ @abstract_method
+ def __invert__(self):
+ r"""
+ Inverse operator.
+
+ If `f` denotes the current coordinate function and `K` the topological
+ field over which the manifold is defined, the *inverse* of `f` is the
+ coordinate function `1 / f`, where `1` of the multiplicative identity
+ of `K`.
+
+ OUTPUT:
+
+ - the inverse of ``self``
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.__invert__()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method __invert__ at 0x...>
+
+ """
+
+ @abstract_method
+ def _add_(self, other):
+ r"""
+ Addition operator.
+
+ INPUT:
+
+ - ``other`` -- a :class:`CoordFunction` or a value
+
+ OUTPUT:
+
+ - coordinate function resulting from the addition of ``self`` and
+ ``other``
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._add_(2)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _add_ at 0x...>
+
+ """
+
+ @abstract_method
+ def _sub_(self, other):
+ r"""
+ Subtraction operator.
+
+ INPUT:
+
+ - ``other`` -- a :class:`CoordFunction` or a value
+
+ OUTPUT:
+
+ - coordinate function resulting from the subtraction of ``other`` from
+ ``self``
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._sub_(2)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _sub_ at 0x...>
+
+ """
+
+ @abstract_method
+ def _mul_(self, other):
+ r"""
+ Multiplication operator.
+
+ INPUT:
+
+ - ``other`` -- a :class:`CoordFunction` or a value
+
+ OUTPUT:
+
+ - coordinate function resulting from the multiplication of ``self`` by
+ ``other``
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._mul_(2)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _mul_ at 0x...>
+
+ """
+
+ @abstract_method
+ def _div_(self, other):
+ r"""
+ Division operator.
+
+ INPUT:
+
+ - ``other`` -- a :class:`CoordFunction` or a value
+
+ OUTPUT:
+
+ - coordinate function resulting from the division of ``self`` by
+ ``other``
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f._div_(2)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method _div_ at 0x...>
+
+ """
+
+ @abstract_method
+ def exp(self):
+ r"""
+ Exponential of ``self``.
+
+ OUTPUT:
+
+ - coordinate function `\exp(f)`, where `f` is the current coordinate
+ function.
+
+ TESTS:
+
+ This method must be implemented by derived classes; it is not
+ implemented here::
+
+ sage: M = Manifold(2, 'M', structure='topological')
+ sage: X.<x,y> = M.chart()
+ sage: from sage.manifolds.coord_func import CoordFunction
+ sage: f = CoordFunction(X.function_ring())
+ sage: f.exp()
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: <abstract method exp at 0x...>
+
+ """
+
+ @abstract_method
+ def log(self, base=None):
+ r"""
+ Logarithm of ``self``.
+
+ INPUT:
+
+ - ``base`` -- (default: ``None``) base of the logarithm; if None, the
+ natural logarithm (i.e