passagemath-plot 10.6.31rc3__cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sage/plot/primitive.py

@@ -0,0 +1,249 @@
+# sage_setup: distribution = sagemath-plot
+"""
+Plotting primitives
+"""
+#*****************************************************************************
+#       Copyright (C) 2006 Alex Clemesha <clemesha@gmail.com>,
+#                          William Stein <wstein@gmail.com>,
+#                     2008 Mike Hansen <mhansen@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:
+#
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+from sage.misc.fast_methods import WithEqualityById
+from sage.structure.sage_object import SageObject
+from sage.misc.verbose import verbose
+
+
+class GraphicPrimitive(WithEqualityById, SageObject):
+    """
+    Base class for graphics primitives, e.g., things that knows how to draw
+    themselves in 2D.
+
+    EXAMPLES:
+
+    We create an object that derives from GraphicPrimitive::
+
+        sage: P = line([(-1,-2), (3,5)])
+        sage: P[0]
+        Line defined by 2 points
+        sage: type(P[0])
+        <class 'sage.plot.line.Line'>
+
+    TESTS::
+
+        sage: hash(circle((0,0),1))  # random
+        42
+    """
+    def __init__(self, options):
+        """
+        Create a base class GraphicsPrimitive.  All this does is
+        set the options.
+
+        EXAMPLES:
+
+        We indirectly test this function::
+
+            sage: from sage.plot.primitive import GraphicPrimitive
+            sage: GraphicPrimitive({})
+            Graphics primitive
+        """
+        self._options = options
+
+    def _allowed_options(self):
+        """
+        Return the allowed options for a graphics primitive.
+
+        OUTPUT: a reference to a dictionary
+
+        EXAMPLES::
+
+            sage: from sage.plot.primitive import GraphicPrimitive
+            sage: GraphicPrimitive({})._allowed_options()
+            {}
+        """
+        return {}
+
+    def plot3d(self, **kwds):
+        """
+        Plots 3D version of 2D graphics object.  Not implemented
+        for base class.
+
+        EXAMPLES::
+
+            sage: from sage.plot.primitive import GraphicPrimitive
+            sage: G=GraphicPrimitive({})
+            sage: G.plot3d()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: 3D plotting not implemented for Graphics primitive
+        """
+        raise NotImplementedError("3D plotting not implemented for %s" % self._repr_())
+
+    def _plot3d_options(self, options=None):
+        """
+        Translate 2D plot options into 3D plot options.
+
+        EXAMPLES::
+
+            sage: P = line([(-1,-2), (3,5)], alpha=.5, thickness=4)
+            sage: p = P[0]; p
+            Line defined by 2 points
+            sage: q=p.plot3d()
+            sage: q.thickness
+            4
+            sage: q.texture.opacity
+            0.5
+        """
+        if options is None:
+            options = self.options()
+        options_3d = {}
+        if 'rgbcolor' in options:
+            options_3d['rgbcolor'] = options['rgbcolor']
+            del options['rgbcolor']
+        if 'alpha' in options:
+            options_3d['opacity'] = options['alpha']
+            del options['alpha']
+
+        for o in ('legend_color', 'legend_label', 'zorder'):
+            if o in options:
+                del options[o]
+
+        if len(options) != 0:
+            raise NotImplementedError("Unknown plot3d equivalent for {}".format(
+                                      ", ".join(options.keys())))
+        return options_3d
+
+    def set_zorder(self, zorder):
+        """
+        Set the layer in which to draw the object.
+
+        EXAMPLES::
+
+            sage: P = line([(-2,-3), (3,4)], thickness=4)
+            sage: p=P[0]
+            sage: p.set_zorder(2)
+            sage: p.options()['zorder']
+            2
+            sage: Q = line([(-2,-4), (3,5)], thickness=4,zorder=1,hue=.5)
+            sage: P+Q # blue line on top
+            Graphics object consisting of 2 graphics primitives
+            sage: q=Q[0]
+            sage: q.set_zorder(3)
+            sage: P+Q # teal line on top
+            Graphics object consisting of 2 graphics primitives
+            sage: q.options()['zorder']
+            3
+        """
+        self._options['zorder'] = zorder
+
+    def set_options(self, new_options):
+        """
+        Change the options to ``new_options``.
+
+        EXAMPLES::
+
+            sage: from sage.plot.circle import Circle
+            sage: c = Circle(0,0,1,{})
+            sage: c.set_options({'thickness': 0.6})
+            sage: c.options()
+            {'thickness': 0.6...}
+        """
+        if new_options is not None:
+            self._options = new_options
+
+    def options(self):
+        """
+        Return the dictionary of options for this graphics primitive.
+
+        By default this function verifies that the options are all
+        valid; if any aren't, then a verbose message is printed with level 0.
+
+        EXAMPLES::
+
+            sage: from sage.plot.primitive import GraphicPrimitive
+            sage: GraphicPrimitive({}).options()
+            {}
+        """
+        from sage.plot.graphics import do_verify
+        from sage.plot.colors import hue
+        O = dict(self._options)
+        if do_verify:
+            A = self._allowed_options()
+            t = False
+            K = list(A) + ['xmin', 'xmax', 'ymin', 'ymax', 'axes']
+            for k, Ok in O.items():
+                if k not in K:
+                    do_verify = False
+                    verbose(f"WARNING: Ignoring option '{k}'={Ok}",
+                            level=0)
+                    t = True
+            if t:
+                s = "\nThe allowed options for %s are:\n" % self
+                K.sort()
+                for k in K:
+                    if k in A:
+                        s += "    %-15s%-60s\n" % (k, A[k])
+                verbose(s, level=0)
+
+        if 'hue' in O:
+            t = O['hue']
+            if not isinstance(t, (tuple, list)):
+                t = [t, 1, 1]
+            O['rgbcolor'] = hue(*t)
+            del O['hue']
+        return O
+
+    def _repr_(self):
+        """
+        String representation of this graphics primitive.
+
+        EXAMPLES::
+
+            sage: from sage.plot.primitive import GraphicPrimitive
+            sage: GraphicPrimitive({})._repr_()
+            'Graphics primitive'
+        """
+        return "Graphics primitive"
+
+
+class GraphicPrimitive_xydata(GraphicPrimitive):
+    def get_minmax_data(self):
+        """
+        Return a dictionary with the bounding box data.
+
+        EXAMPLES::
+
+            sage: d = polygon([[1,2], [5,6], [5,0]], rgbcolor=(1,0,1))[0].get_minmax_data()
+            sage: d['ymin']
+            0.0
+            sage: d['xmin']
+            1.0
+
+        ::
+
+            sage: d = point((3, 3), rgbcolor=hue(0.75))[0].get_minmax_data()
+            sage: d['xmin']
+            3.0
+            sage: d['ymin']
+            3.0
+
+        ::
+
+            sage: l = line([(100, 100), (120, 120)])[0]
+            sage: d = l.get_minmax_data()
+            sage: d['xmin']
+            100.0
+            sage: d['xmax']
+            120.0
+        """
+        from sage.plot.plot import minmax_data
+        return minmax_data(self.xdata, self.ydata, dict=True)

sage/plot/scatter_plot.py

@@ -0,0 +1,199 @@
+# sage_setup: distribution = sagemath-plot
+"""
+Scatter plots
+"""
+
+# *****************************************************************************
+#       Copyright (C) 2006 Alex Clemesha <clemesha@gmail.com>,
+#                          William Stein <wstein@gmail.com>,
+#                     2008 Mike Hansen <mhansen@gmail.com>,
+#                     2009 Emily Kirkman
+#                     2022 Javier Honrubia <jhonrubia6@alumno.uned.es>
+#
+#  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:
+#
+#                  http://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.plot.primitive import GraphicPrimitive
+from sage.misc.decorators import options
+
+
+class ScatterPlot(GraphicPrimitive):
+    """
+    Scatter plot graphics primitive.
+
+    Input consists of two lists/arrays of the same length, whose
+    values give the horizontal and vertical coordinates of each
+    point in the scatter plot.  Options may be passed in
+    dictionary format.
+
+    EXAMPLES::
+
+        sage: from sage.plot.scatter_plot import ScatterPlot
+        sage: ScatterPlot([0,1,2], [3.5,2,5.1], {'facecolor':'white', 'marker':'s'})
+        Scatter plot graphics primitive on 3 data points
+    """
+    def __init__(self, xdata, ydata, options):
+        """
+        Scatter plot graphics primitive.
+
+        EXAMPLES::
+
+            sage: import numpy
+            sage: from sage.plot.scatter_plot import ScatterPlot
+            sage: ScatterPlot(numpy.array([0,1,2]), numpy.array([3.5,2,5.1]), {'facecolor':'white', 'marker':'s'})
+            Scatter plot graphics primitive on 3 data points
+        """
+        self.xdata = xdata
+        self.ydata = ydata
+        GraphicPrimitive.__init__(self, options)
+
+    def get_minmax_data(self):
+        """
+        Return a dictionary with the bounding box data.
+
+        EXAMPLES::
+
+            sage: s = scatter_plot([[0,1],[2,4],[3.2,6]])
+            sage: d = s.get_minmax_data()
+            sage: d['xmin']
+            ...0.0...
+            sage: d['ymin']
+            ...1.0...
+        """
+        return {'xmin': self.xdata.min(),
+                'xmax': self.xdata.max(),
+                'ymin': self.ydata.min(),
+                'ymax': self.ydata.max()}
+
+    def _allowed_options(self):
+        """
+        Return the dictionary of allowed options for the scatter plot
+        graphics primitive.
+
+        EXAMPLES::
+
+            sage: from sage.plot.scatter_plot import ScatterPlot
+            sage: list(sorted(ScatterPlot([-1,2], [17,4], {})._allowed_options().items()))
+            [('alpha', 'How transparent the marker border is.'),
+            ('clip', 'Whether or not to clip.'),
+            ('edgecolor', 'The color of the marker border.'),
+            ('facecolor', 'The color of the marker face.'),
+            ('hue', 'The color given as a hue.'),
+            ('marker', 'What shape to plot the points. See the documentation of plot() for the full list of markers.'),
+            ('markersize', 'the size of the markers.'),
+            ('rgbcolor', 'The color as an RGB tuple.'),
+            ('zorder', 'The layer level in which to draw.')]
+        """
+        return {'markersize': 'the size of the markers.',
+                'marker': 'What shape to plot the points. See the documentation of plot() for the full list of markers.',
+                'alpha': 'How transparent the marker border is.',
+                'rgbcolor': 'The color as an RGB tuple.',
+                'hue': 'The color given as a hue.',
+                'facecolor': 'The color of the marker face.',
+                'edgecolor': 'The color of the marker border.',
+                'zorder': 'The layer level in which to draw.',
+                'clip': 'Whether or not to clip.'}
+
+    def _repr_(self):
+        """
+        Text representation of a scatter plot graphics primitive.
+
+        EXAMPLES::
+
+            sage: import numpy
+            sage: from sage.plot.scatter_plot import ScatterPlot
+            sage: ScatterPlot(numpy.array([0,1,2]), numpy.array([3.5,2,5.1]), {})
+            Scatter plot graphics primitive on 3 data points
+        """
+        return 'Scatter plot graphics primitive on %s data points' % len(self.xdata)
+
+    def _render_on_subplot(self, subplot):
+        """
+        Render this scatter plot in a subplot.  This is the key function that
+        defines how this scatter plot graphics primitive is rendered in
+        matplotlib's library.
+
+        EXAMPLES::
+
+            sage: scatter_plot([[0,1],[2,2],[4.3,1.1]], marker='s')
+            Graphics object consisting of 1 graphics primitive
+
+        ::
+
+            sage: scatter_plot([[n,n] for n in range(5)])
+            Graphics object consisting of 1 graphics primitive
+        """
+        options = self.options()
+        p = subplot.scatter(self.xdata, self.ydata, alpha=options['alpha'],
+                            zorder=options['zorder'], marker=options['marker'],
+                            s=options['markersize'], facecolors=options['facecolor'],
+                            edgecolors=options['edgecolor'], clip_on=options['clip'])
+        if not options['clip']:
+            self._bbox_extra_artists = [p]
+
+
+@options(alpha=1, markersize=50, marker='o', zorder=5, facecolor='#fec7b8', edgecolor='black', clip=True, aspect_ratio='automatic')
+def scatter_plot(datalist, **options):
+    """
+    Return a Graphics object of a scatter plot containing all points in
+    the datalist.  Type ``scatter_plot.options`` to see all available
+    plotting options.
+
+    INPUT:
+
+    - ``datalist`` -- list of tuples ``(x,y)``
+
+    - ``alpha`` -- (default: 1)
+
+    - ``markersize`` -- (default: 50)
+
+    - ``marker`` -- the style of the markers (default: ``'o'``); see the
+      documentation of :func:`plot` for the full list of markers
+
+    - ``facecolor`` -- (default: ``'#fec7b8'``)
+
+    - ``edgecolor`` -- (default: ``'black'``)
+
+    - ``zorder`` -- (default: 5)
+
+    EXAMPLES::
+
+        sage: scatter_plot([[0,1],[2,2],[4.3,1.1]], marker='s')
+        Graphics object consisting of 1 graphics primitive
+
+    .. PLOT::
+
+        from sage.plot.scatter_plot import ScatterPlot
+        S = scatter_plot([[0,1],[2,2],[4.3,1.1]], marker='s')
+        sphinx_plot(S)
+
+    Extra options will get passed on to :meth:`~Graphics.show`, as long as they are valid::
+
+        sage: scatter_plot([(0, 0), (1, 1)], markersize=100, facecolor='green', ymax=100)
+        Graphics object consisting of 1 graphics primitive
+        sage: scatter_plot([(0, 0), (1, 1)], markersize=100, facecolor='green').show(ymax=100) # These are equivalent
+
+    .. PLOT::
+
+        from sage.plot.scatter_plot import ScatterPlot
+        S = scatter_plot([(0, 0), (1, 1)], markersize=100, facecolor='green', ymax=100)
+        sphinx_plot(S)
+    """
+    import numpy
+    from sage.plot.all import Graphics
+    g = Graphics()
+    g._set_extra_kwds(Graphics._extract_kwds_for_show(options))
+    data = numpy.array(datalist, dtype='float')
+    if len(data) != 0:
+        xdata = data[:, 0]
+        ydata = data[:, 1]
+        g.add_primitive(ScatterPlot(xdata, ydata, options=options))
+    return g

sage/plot/step.py

@@ -0,0 +1,85 @@
+# sage_setup: distribution = sagemath-plot
+# sage.doctest: needs sage.symbolic
+"""
+Step function plots
+"""
+
+# *****************************************************************************
+#       Copyright (C) 2009 William Stein <wstein@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:
+#
+#                  http://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.plot.line import line
+
+
+def plot_step_function(v, vertical_lines=True, **kwds):
+    r"""
+    Return the line graphics object that gives the plot of the step
+    function `f` defined by the list `v` of pairs `(a,b)`.  Here if
+    `(a,b)` is in `v`, then `f(a) = b`.  The user does not have to
+    worry about sorting the input list `v`.
+
+    INPUT:
+
+    - ``v`` -- list of pairs (a,b)
+
+    - ``vertical_lines`` -- boolean (default: ``True``); if ``True``, draw
+      vertical risers at each step of this step function.
+      Technically these vertical lines are not part of the graph
+      of this function, but they look very nice in the plot, so we
+      include them by default.
+
+    EXAMPLES:
+
+    We plot the prime counting function::
+
+        sage: plot_step_function([(i, prime_pi(i)) for i in range(20)])
+        Graphics object consisting of 1 graphics primitive
+
+    .. PLOT::
+
+        sphinx_plot(plot_step_function([(i, prime_pi(i)) for i in range(20)]))
+
+    ::
+
+        sage: plot_step_function([(i, sin(i)) for i in range(5, 20)])
+        Graphics object consisting of 1 graphics primitive
+
+    .. PLOT::
+
+        sphinx_plot(plot_step_function([(i, sin(i)) for i in range(5, 20)]))
+
+    We pass in many options and get something that looks like "Space Invaders"::
+
+        sage: v = [(i, sin(i)) for i in range(5, 20)]
+        sage: plot_step_function(v, vertical_lines=False, thickness=30,
+        ....:                    rgbcolor='purple', axes=False)
+        Graphics object consisting of 14 graphics primitives
+
+    .. PLOT::
+
+        v = [(i, sin(i)) for i in range(5, 20)]
+        sphinx_plot(plot_step_function(v, vertical_lines=False, thickness=30, rgbcolor='purple', axes=False))
+    """
+    # make sorted copy of v (don't change in place, since that would be rude).
+    v = sorted(v)
+    if len(v) <= 1:
+        return line([])  # empty line
+    if vertical_lines:
+        w = []
+        for i in range(len(v)):
+            w.append(v[i])
+            if i+1 < len(v):
+                w.append((v[i+1][0], v[i][1]))
+        return line(w, **kwds)
+    else:
+        return sum(line([v[i], (v[i+1][0], v[i][1])], **kwds) for i in range(len(v)-1))