passagemath-plot 10.6.31rc3__cp314-cp314-macosx_13_0_arm64.whl

sage/plot/plot3d/plot_field3d.py

@@ -0,0 +1,162 @@
+# sage_setup: distribution = sagemath-plot
+# sage.doctest: needs sage.symbolic
+"""
+Plotting 3D fields
+"""
+# ****************************************************************************
+#       Copyright (C) 2009 Jason Grout <jason-sage@creativetrax.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.arith.srange import srange
+from sage.plot.misc import setup_for_eval_on_grid
+from sage.modules.free_module_element import vector
+from sage.plot.plot import plot
+
+
+def plot_vector_field3d(functions, xrange, yrange, zrange,
+                        plot_points=5, colors='jet', center_arrows=False, **kwds):
+    r"""
+    Plot a 3d vector field.
+
+    INPUT:
+
+    - ``functions`` -- list of three functions, representing the x-,
+      y-, and z-coordinates of a vector
+
+    - ``xrange``, ``yrange``, and ``zrange`` -- three tuples of the
+      form (var, start, stop), giving the variables and ranges for each axis
+
+    - ``plot_points`` -- (default: 5) either a number or list of three
+      numbers, specifying how many points to plot for each axis
+
+    - ``colors`` -- (default: ``'jet'``) a color, list of colors (which are
+      interpolated between), or matplotlib colormap name, giving the coloring
+      of the arrows.  If a list of colors or a colormap is given,
+      coloring is done as a function of length of the vector
+
+    - ``center_arrows`` -- (default: ``False``) if ``True``, draw the arrows
+      centered on the points; otherwise, draw the arrows with the tail
+      at the point
+
+    - any other keywords are passed on to the :func:`plot` command for each arrow
+
+    EXAMPLES:
+
+    A 3d vector field::
+
+      sage: x,y,z = var('x y z')
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi))
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi)))
+
+    same example with only a list of colors::
+
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi),
+      ....:                     colors=['red','green','blue'])
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),colors=['red','green','blue']))
+
+    same example with only one color::
+
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi), colors='red')
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),colors='red'))
+
+    same example with the same plot points for the three axes::
+
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi), plot_points=4)
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),plot_points=4))
+
+    same example with different number of plot points for each axis::
+
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi), plot_points=[3,5,7])
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),plot_points=[3,5,7]))
+
+    same example with the arrows centered on the points::
+
+      sage: plot_vector_field3d((x*cos(z), -y*cos(z), sin(z)),
+      ....:                     (x,0,pi), (y,0,pi), (z,0,pi), center_arrows=True)
+      Graphics3d Object
+
+    .. PLOT::
+
+      x,y,z=var('x y z')
+      sphinx_plot(plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),center_arrows=True))
+
+
+    TESTS:
+
+    This tests that :issue:`2100` is fixed in a way compatible with this command::
+
+        sage: plot_vector_field3d((x*cos(z),-y*cos(z),sin(z)), (x,0,pi), (y,0,pi), (z,0,pi),center_arrows=True,aspect_ratio=(1,2,1))
+        Graphics3d Object
+    """
+    (ff, gg, hh), ranges = setup_for_eval_on_grid(functions, [xrange, yrange, zrange], plot_points)
+    xpoints, ypoints, zpoints = (srange(*r, include_endpoint=True) for r in ranges)
+    points = [vector((i, j, k)) for i in xpoints for j in ypoints for k in zpoints]
+    vectors = [vector((ff(*point), gg(*point), hh(*point))) for point in points]
+
+    try:
+        import matplotlib as mpl
+        cm = mpl.colormaps[colors]
+    except (TypeError, KeyError):
+        cm = None
+    if cm is None:
+        if isinstance(colors, (list, tuple)):
+            from matplotlib.colors import LinearSegmentedColormap
+            cm = LinearSegmentedColormap.from_list('mymap', colors)
+        else:
+            def cm(x):
+                return colors
+
+    max_len = max(v.norm() for v in vectors)
+    scaled_vectors = [v / max_len for v in vectors]
+
+    if center_arrows:
+        G = sum(plot(v, color=cm(v.norm()), **kwds).translate(p - v / 2)
+                for v, p in zip(scaled_vectors, points))
+        G._set_extra_kwds(kwds)
+        return G
+    else:
+        G = sum(plot(v, color=cm(v.norm()), **kwds).translate(p)
+                for v, p in zip(scaled_vectors, points))
+        G._set_extra_kwds(kwds)
+        return G

sage/plot/plot3d/point_c.pxi

@@ -0,0 +1,148 @@
+# sage_setup: distribution = sagemath-plot
+# ****************************************************************************
+#      Copyright (C) 2007 Robert Bradshaw <robertwb@math.washington.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+# Utility functions for operating on the point_c struct.
+from libc cimport math
+
+
+cdef inline bint point_c_set(point_c* res, P) except -2:
+    res.x, res.y, res.z = P[0], P[1], P[2]
+
+cdef inline bint point_c_eq(point_c P, point_c Q) noexcept:
+    return P.x == Q.x and P.y == Q.y and P.z == Q.z
+
+cdef inline bint point_c_isfinite(point_c P) noexcept:
+    return math.isfinite(P.x) and math.isfinite(P.y) and math.isfinite(P.z)
+
+cdef inline int point_c_cmp(point_c P, point_c Q) noexcept:
+    """
+    Lexographic order
+    """
+    if P.x == Q.x:
+        if P.y == Q.y:
+            if P.z == Q.z:
+                return 0
+            elif P.z < Q.z:
+                return -1
+            else:
+                return 1
+        elif P.y < Q.y:
+            return -1
+        else:
+            return 1
+    elif P.x < Q.x:
+        return -1
+    else:
+        return 1
+
+cdef inline void point_c_update_finite_lower_bound(point_c* res, point_c P) noexcept:
+    # We use the condition "not P.x > res.x" so that the condition returns True if res.x is NaN
+    if math.isfinite(P.x) and not P.x > res.x:
+        res.x = P.x
+    if math.isfinite(P.y) and not P.y > res.y:
+        res.y = P.y
+    if math.isfinite(P.z) and not P.z > res.z:
+        res.z = P.z
+
+cdef inline void point_c_update_finite_upper_bound(point_c* res, point_c P) noexcept:
+    # We use the condition "not P.x < res.x" so that the condition returns True if res.x is NaN
+    if math.isfinite(P.x) and not P.x < res.x:
+        res.x = P.x
+    if math.isfinite(P.y) and not P.y < res.y:
+        res.y = P.y
+    if math.isfinite(P.z) and not P.z < res.z:
+        res.z = P.z
+
+cdef inline void point_c_lower_bound(point_c* res, point_c P, point_c Q) noexcept:
+    res.x = P.x if P.x < Q.x else Q.x
+    res.y = P.y if P.y < Q.y else Q.y
+    res.z = P.z if P.z < Q.z else Q.z
+
+cdef inline void point_c_upper_bound(point_c* res, point_c P, point_c Q) noexcept:
+    res.x = P.x if P.x > Q.x else Q.x
+    res.y = P.y if P.y > Q.y else Q.y
+    res.z = P.z if P.z > Q.z else Q.z
+
+cdef inline void point_c_add(point_c* res, point_c P, point_c Q) noexcept:
+    res.x = P.x + Q.x
+    res.y = P.y + Q.y
+    res.z = P.z + Q.z
+
+cdef inline void point_c_sub(point_c* res, point_c P, point_c Q) noexcept:
+    res.x = P.x - Q.x
+    res.y = P.y - Q.y
+    res.z = P.z - Q.z
+
+cdef inline void point_c_mul(point_c* res, point_c P, double a) noexcept:
+    res.x = a * P.x
+    res.y = a * P.y
+    res.z = a * P.z
+
+cdef inline double point_c_dot(point_c P, point_c Q) noexcept:
+    return P.x*Q.x + P.y*Q.y + P.z*Q.z
+
+cdef inline void point_c_cross(point_c* res, point_c P, point_c Q) noexcept:
+    res.x = P.y * Q.z - P.z * Q.y
+    res.y = P.z * Q.x - P.x * Q.z
+    res.z = P.x * Q.y - P.y * Q.x
+
+cdef inline double point_c_len(point_c P) noexcept:
+    return math.sqrt(point_c_dot(P, P))
+
+cdef inline void point_c_middle(point_c* res, point_c P, point_c Q, double a) noexcept:
+    cdef double b = 1 - a
+    res.x = b * P.x + a * Q.x
+    res.y = b * P.y + a * Q.y
+    res.z = b * P.z + a * Q.z
+
+cdef inline void point_c_transform(point_c* res, double* M, point_c P) noexcept:
+    """
+    M is a flattened 4x4 matrix, row major, representing a Euclidean Transformation.
+    Operate on P as a point.
+    """
+    res.x = M[0]*P.x + M[1]*P.y + M[2]*P.z + M[3]
+    res.y = M[4]*P.x + M[5]*P.y + M[6]*P.z + M[7]
+    res.z = M[8]*P.x + M[9]*P.y + M[10]*P.z + M[11]
+
+cdef inline void point_c_stretch(point_c* res, double* M, point_c P) noexcept:
+    """
+    M is a flattened 4x4 matrix, row major, representing a Euclidean Transformation.
+    Operate on P as a vector (i.e. ignore the translation component)
+    """
+    res.x = M[0]*P.x + M[1]*P.y + M[2]*P.z
+    res.y = M[4]*P.x + M[5]*P.y + M[6]*P.z
+    res.z = M[8]*P.x + M[9]*P.y + M[10]*P.z
+
+cdef inline void face_c_normal(point_c* res, face_c face, point_c* vlist) noexcept:
+    cdef point_c e1, e2
+    point_c_sub(&e1, vlist[face.vertices[0]], vlist[face.vertices[1]])
+    point_c_sub(&e2, vlist[face.vertices[2]], vlist[face.vertices[1]])
+    point_c_cross(res, e1, e2)
+
+cdef inline double cos_face_angle(face_c F, face_c E, point_c* vlist) noexcept:
+    cdef point_c nF, nE
+    face_c_normal(&nF, F, vlist)
+    face_c_normal(&nE, E, vlist)
+    cdef double dot = point_c_dot(nF, nE)
+    return dot / math.sqrt(point_c_dot(nF, nF)*point_c_dot(nE, nE))
+
+cdef inline double sin_face_angle(face_c F, face_c E, point_c* vlist) noexcept:
+    cdef point_c nF, nE
+    face_c_normal(&nF, F, vlist)
+    face_c_normal(&nE, E, vlist)
+    cdef double dot = point_c_dot(nF, nE)
+    return math.sqrt(1-(dot*dot)/(point_c_dot(nF, nF)*point_c_dot(nE, nE)))

sage/plot/plot3d/revolution_plot3d.py

@@ -0,0 +1,309 @@
+# sage_setup: distribution = sagemath-plot
+# sage.doctest: needs sage.plot sage.symbolic
+"""
+Surfaces of revolution
+
+AUTHORS:
+
+- Oscar Gerardo Lazo Arjona (2010): initial version.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2010 Oscar Gerardo Lazo Arjona algebraicamente@gmail.com
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from sage.misc.decorators import rename_keyword
+
+from sage.plot.plot3d.parametric_plot3d import parametric_plot3d
+
+
+@rename_keyword(alpha='opacity')
+def revolution_plot3d(curve, trange, phirange=None, parallel_axis='z', axis=(0, 0), print_vector=False, show_curve=False, **kwds):
+    r"""
+    Return a plot of a revolved curve.
+
+    There are three ways to call this function:
+
+    - ``revolution_plot3d(f,trange)`` where `f` is a function located in the
+      `x z` plane.
+
+    - ``revolution_plot3d((f_x,f_z),trange)`` where `(f_x,f_z)` is a parametric
+      curve on the `x z` plane.
+
+    - ``revolution_plot3d((f_x,f_y,f_z),trange)`` where `(f_x,f_y,f_z)` can be
+      any parametric curve.
+
+    INPUT:
+
+    - ``curve`` -- a curve to be revolved, specified as a function, a 2-tuple
+      or a 3-tuple
+
+    - ``trange`` -- a 3-tuple `(t,t_{\min},t_{\max})` where t is the
+      independent variable of the curve
+
+    - ``phirange`` -- a 2-tuple of the form `(\phi_{\min},\phi_{\max})`
+      (default: `(0,\pi)`) that specifies the angle in which the curve is to be
+      revolved
+
+    - ``parallel_axis`` -- string (one of ``'x'``, ``'y'``, ``'z'``) that
+      specifies the coordinate axis parallel to the revolution axis
+
+    - ``axis`` -- a 2-tuple that specifies the position of the revolution axis.
+      If ``parallel_axis`` is:
+
+      - ``'z'`` -- then ``axis`` is the point in which the revolution axis
+        intersects the  `x` `y` plane
+
+      - ``'x'`` -- then ``axis`` is the point in which the revolution axis
+        intersects the  `y` `z` plane
+
+      - ``'y'`` -- then ``axis`` is the point in which the revolution axis
+        intersects the `x` `z` plane
+
+    - ``print_vector`` -- if ``True``, the parametrization of the surface of
+      revolution will be printed
+
+    - ``show_curve`` -- if ``True``, the curve will be displayed
+
+    EXAMPLES:
+
+    Let's revolve a simple function around different axes::
+
+        sage: u = var('u')
+        sage: f = u^2
+        sage: revolution_plot3d(f, (u,0,2),
+        ....:                   show_curve=True, opacity=0.7).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        f = u**2
+        P = revolution_plot3d(f, (u,0,2), show_curve=True, opacity=0.7).plot()
+        sphinx_plot(P)
+
+    If we move slightly the axis, we get a goblet-like surface::
+
+        sage: revolution_plot3d(f, (u,0,2), axis=(1,0.2),
+        ....:                   show_curve=True, opacity=0.5).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        f = u**2
+        P = revolution_plot3d(f, (u,0,2), axis=(1,0.2), show_curve=True, opacity=0.5).plot()
+        sphinx_plot(P)
+
+    A common problem in calculus books, find the volume within the following revolution solid::
+
+        sage: line = u
+        sage: parabola = u^2
+        sage: sur1 = revolution_plot3d(line, (u,0,1), opacity=0.5, rgbcolor=(1,0.5,0),
+        ....:                          show_curve=True, parallel_axis='x')
+        sage: sur2 = revolution_plot3d(parabola, (u,0,1), opacity=0.5, rgbcolor=(0,1,0),
+        ....:                          show_curve=True, parallel_axis='x')
+        sage: (sur1 + sur2).show()
+
+    .. PLOT::
+
+        u = var('u')
+        line = u
+        parabola = u**2
+        sur1 = revolution_plot3d(line, (u,0,1), opacity=0.5, rgbcolor=(1,0.5,0), show_curve=True, parallel_axis='x')
+        sur2 = revolution_plot3d(parabola, (u,0,1), opacity=0.5, rgbcolor=(0,1,0), show_curve=True, parallel_axis='x')
+        P = sur1 + sur2
+        sphinx_plot(P)
+
+    Now let's revolve a parametrically defined circle. We can play with the topology of the surface by changing the axis,
+    an axis in `(0,0)` (as the previous one) will produce a sphere-like surface::
+
+        sage: u = var('u')
+        sage: circle = (cos(u), sin(u))
+        sage: revolution_plot3d(circle, (u,0,2*pi), axis=(0,0),
+        ....:                   show_curve=True, opacity=0.5).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        circle = (cos(u), sin(u))
+        P = revolution_plot3d(circle, (u,0,2*pi), axis=(0,0), show_curve=True, opacity=0.5)
+        sphinx_plot(P)
+
+    An axis on `(0,y)` will produce a cylinder-like surface::
+
+        sage: revolution_plot3d(circle, (u,0,2*pi), axis=(0,2),
+        ....:                   show_curve=True, opacity=0.5).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        circle = (cos(u), sin(u))
+        P = revolution_plot3d(circle, (u,0,2*pi), axis=(0,2), show_curve=True, opacity=0.5)
+        sphinx_plot(P)
+
+    And any other axis will produce a torus-like surface::
+
+        sage: revolution_plot3d(circle, (u,0,2*pi), axis=(2,0),
+        ....:                   show_curve=True, opacity=0.5).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        circle = (cos(u), sin(u))
+        P = revolution_plot3d(circle, (u,0,2*pi), axis=(2,0), show_curve=True, opacity=0.5)
+        sphinx_plot(P)
+
+    Now, we can get another goblet-like surface by revolving a curve in 3d::
+
+        sage: u = var('u')
+        sage: curve = (u, cos(4*u), u^2)
+        sage: P = revolution_plot3d(curve, (u,0,2), parallel_axis='z', axis=(1,.2),
+        ....:                       show_curve=True, opacity=0.5)
+        sage: P.show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u = var('u')
+        curve = (u, cos(4*u), u**2)
+        P = revolution_plot3d(curve, (u,0,2), show_curve=True, parallel_axis='z', axis=(1,.2), opacity=0.5)
+        sphinx_plot(P)
+
+    A curvy curve with only a quarter turn::
+
+        sage: u = var('u')
+        sage: curve = (sin(3*u), .8*cos(4*u), cos(u))
+        sage: revolution_plot3d(curve, (u,0,pi), (0,pi/2), parallel_axis='z',
+        ....:                   show_curve=True, opacity=0.5).show(aspect_ratio=(1,1,1),
+        ....:                                                      frame=False)
+
+    .. PLOT::
+
+        u = var('u')
+        curve = (sin(3*u), .8*cos(4*u), cos(u))
+        P = revolution_plot3d(curve, (u,0,pi), (0,pi/2), show_curve=True, parallel_axis='z', opacity=0.5)
+        sphinx_plot(P)
+
+    One can also color the surface using a coloring function of two
+    parameters and a colormap as follows. Note that the coloring
+    function must take values in the interval `[0,1]`. ::
+
+        sage: u, phi = var('u,phi')
+        sage: def cf(u, phi): return sin(phi+u) ^ 2
+        sage: curve = (1+u^2/4, 0, u)
+        sage: revolution_plot3d(curve, (u,-2,2), (0,2*pi), parallel_axis='z',
+        ....:                   color=(cf, colormaps.PiYG)).show(aspect_ratio=(1,1,1))
+
+    .. PLOT::
+
+        u, phi = var('u,phi')
+        def cf(u, phi): return sin(phi+u) ** 2
+        curve = (1+u**2/4, 0, u)
+        P = revolution_plot3d(curve, (u,-2,2), (0,2*pi), parallel_axis='z', color=(cf, colormaps.PiYG))
+        sphinx_plot(P)
+
+    The first parameter of the coloring function will be identified with the
+    parameter of the curve, and the second with the angle parameter.
+
+    Another colored example, illustrating that one can use (colormap, color function) instead of (color function, colormap)::
+
+        sage: u, phi = var('u,phi')
+        sage: def cf(u, phi): return float(2 * u / pi) % 1
+        sage: curve = (sin(u), 0, u)
+        sage: revolution_plot3d(curve, (u,0,pi), (0,2*pi), parallel_axis='z',
+        ....:                   color=(colormaps.brg, cf)).show(aspect_ratio=1)
+
+    .. PLOT::
+
+        u, phi = var('u,phi')
+        def cf(u, phi): return float(2 * u / pi) % 1
+        curve = (sin(u), 0, u)
+        P = revolution_plot3d(curve, (u,0,pi), (0,2*pi), parallel_axis='z', color=(colormaps.brg, cf))
+        sphinx_plot(P)
+    """
+    from sage.symbolic.ring import SR
+    from sage.symbolic.constants import pi
+    from sage.misc.functional import sqrt
+    from sage.functions.trig import sin
+    from sage.functions.trig import cos
+    from sage.functions.trig import atan2
+
+    if parallel_axis not in ['x', 'y', 'z']:
+        raise ValueError("parallel_axis must be either 'x', 'y', or 'z'")
+
+    vart = trange[0]
+
+    if str(vart) == 'phi':
+        phi = SR.var('fi')
+    else:
+        phi = SR.var('phi')
+
+    if phirange is None:  # this if-else provides a phirange
+        phirange = (phi, 0, 2 * pi)
+    elif len(phirange) == 3:
+        phi = phirange[0]
+    else:
+        phirange = (phi, phirange[0], phirange[1])
+
+    if isinstance(curve, (tuple, list)):
+        # this if-else provides a vector v to be plotted
+        # if curve is a tuple or a list of length 2, it is interpreted as a parametric curve
+        # in the x-z plane.
+        # if it is of length 3 it is interpreted as a parametric curve in 3d space
+
+        if len(curve) == 2:
+            x = curve[0]
+            y = 0
+            z = curve[1]
+        elif len(curve) == 3:
+            x = curve[0]
+            y = curve[1]
+            z = curve[2]
+    else:
+        x = vart
+        y = 0
+        z = curve
+
+    phase = 0
+    if parallel_axis == 'z':
+        x0 = axis[0]
+        y0 = axis[1]
+        # (0,0) must be handled separately for the phase value
+        if x0 != 0 or y0 != 0:
+            phase = atan2(y - y0, x - x0)
+        R = sqrt((x-x0)**2 + (y-y0)**2)
+        v = (R*cos(phi+phase)+x0, R*sin(phi+phase)+y0, z)
+    elif parallel_axis == 'x':
+        y0 = axis[0]
+        z0 = axis[1]
+        # (0,0) must be handled separately for the phase value
+        if z0 != 0 or y0 != 0:
+            phase = atan2(z - z0, y - y0)
+        R = sqrt((y-y0)**2 + (z-z0)**2)
+        v = (x, R*cos(phi+phase)+y0, R*sin(phi+phase)+z0)
+    elif parallel_axis == 'y':
+        x0 = axis[0]
+        z0 = axis[1]
+        # (0,0) must be handled separately for the phase value
+        if z0 != 0 or x0 != 0:
+            phase = atan2(z - z0, x - x0)
+        R = sqrt((x-x0)**2 + (z-z0)**2)
+        v = (R*cos(phi+phase)+x0, y, R*sin(phi+phase)+z0)
+
+    if print_vector:
+        print(v)
+
+    if show_curve:
+        curveplot = parametric_plot3d((x, y, z), trange, thickness=2,
+                                      rgbcolor=(1, 0, 0))
+        return parametric_plot3d(v, trange, phirange, **kwds) + curveplot
+
+    return parametric_plot3d(v, trange, phirange, **kwds)

sage/plot/plot3d/shapes.pxd

@@ -0,0 +1,22 @@
+# sage_setup: distribution = sagemath-plot
+from sage.plot.plot3d.parametric_surface cimport ParametricSurface
+
+
+cdef class Cone(ParametricSurface):
+    cdef double radius
+    cdef double height
+    cdef bint closed
+
+
+cdef class Cylinder(ParametricSurface):
+    cdef double radius
+    cdef double height
+    cdef bint closed
+
+
+cdef class Sphere(ParametricSurface):
+    cdef double radius
+
+
+cdef class Torus(ParametricSurface):
+    cdef double R, r