summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorEric Gourgoulhon <eric.gourgoulhon@obspm.fr>2015-12-16 23:34:23 +0100
committerEric Gourgoulhon <eric.gourgoulhon@obspm.fr>2015-12-16 23:34:23 +0100
commitbc770598e606904fb28179960cd8121d30939978 (patch)
tree8d3f47b83e8037692932b7caa8aab91a17e60f04
parentScalar fields on topological manifolds: slight improvements in the documentation (diff)
parentChange in simplify_sqrt_real to cope with the change of != operator induced b... (diff)
Morphisms on the refactored topoological manifolds
-rw-r--r--src/doc/en/reference/manifolds/continuous_map.rst9
-rw-r--r--src/doc/en/reference/manifolds/manifold.rst2
-rw-r--r--src/sage/manifolds/chart.py555
-rw-r--r--src/sage/manifolds/continuous_map.py1830
-rw-r--r--src/sage/manifolds/manifold.py297
-rw-r--r--src/sage/manifolds/manifold_homset.py422
-rw-r--r--src/sage/manifolds/point.py231
-rw-r--r--src/sage/manifolds/structure.py3
-rw-r--r--src/sage/manifolds/utilities.py54
9 files changed, 3401 insertions, 2 deletions
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 00000000..4b67487
--- /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/manifold.rst b/src/doc/en/reference/manifolds/manifold.rst
index 0c4be1f..e9cb7e7 100644
--- a/src/doc/en/reference/manifolds/manifold.rst
+++ b/src/doc/en/reference/manifolds/manifold.rst
@@ -17,3 +17,5 @@ Topological manifolds
chart
scalarfield
+
+ continuous_map
diff --git a/src/sage/manifolds/chart.py b/src/sage/manifolds/chart.py
index 05ea5c3..2a6c57f 100644
--- a/src/sage/manifolds/chart.py
+++ b/src/sage/manifolds/chart.py
@@ -4,6 +4,8 @@ Coordinate charts
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`.
@@ -1277,6 +1279,9 @@ class RealChart(Chart):
sage: c_cart.valid_coordinates(1,0,2)
True
+ Chart grids can be drawn in 2D or 3D graphics thanks to the method
+ :meth:`plot`.
+
"""
def __init__(self, domain, coordinates='', names=None):
r"""
@@ -1819,6 +1824,556 @@ 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
+
#*****************************************************************************
class CoordChange(SageObject):
diff --git a/src/sage/manifolds/continuous_map.py b/src/sage/manifolds/continuous_map.py
new file mode 100644
index 00000000..7277406
--- /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 S. Kobayashi & K. Nomizu : *Foundations of Differential Geometry*,
+ vol. 1, Interscience Publishers (New York) (1963)
+- 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))
+ 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,
+ ....: