passagemath-plot 10.6.31rc3__cp314-cp314-macosx_13_0_arm64.whl

sage/interfaces/gnuplot.py

@@ -0,0 +1,196 @@
+# sage_setup: distribution = sagemath-plot
+r"""
+Interface to the Gnuplot interpreter
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 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:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import os
+import time
+from sage.structure.sage_object import SageObject
+
+
+class Gnuplot(SageObject):
+    """
+    Interface to the Gnuplot interpreter.
+    """
+    def _quit_string(self):
+        return 'quit'
+
+    def gnuplot(self):
+        try:
+            return self._gnuplot
+        except AttributeError:
+            try:
+                import Gnuplot as GP
+                self._gnuplot = GP.Gnuplot()
+                return self._gnuplot
+            except ImportError:
+                raise RuntimeError("Install the gnuplotpy Python module.")
+
+    def __call__(self, line):
+        return self.gnuplot()(line)
+
+    def _eval_line(self, line, *args, **kwds):
+        self(line)
+        return ''
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: gnuplot               # indirect doctests
+            Interface to Gnuplot
+        """
+        return "Interface to Gnuplot"
+
+    def plot(self, cmd, file=None, verbose=True, reset=True):
+        r"""
+        Draw the plot described by cmd, and possibly also save to an eps or
+        png file.
+
+        INPUT:
+
+        - ``cmd`` -- string
+
+        - ``file`` -- string (default: ``None``); if specified save
+          plot to given file, which may be either an eps (default) or png file
+
+        - ``verbose`` -- print some info
+
+        - ``reset`` -- true; reset gnuplot before making graph
+
+        OUTPUT: displays graph
+
+        .. NOTE::
+
+           Note that ``^`` s  are replaced by ``**`` s before being passed to gnuplot.
+        """
+        if reset:
+            self('reset')
+        self('set terminal x11')
+        cmd = cmd.replace('^', '**')
+        self(cmd)
+        if file is not None:
+            if file[-4:] == '.png':
+                self('set terminal png medium')
+            else:
+                if file[-4:] != '.eps':
+                    file += '.eps'
+                self('set terminal postscript eps enhanced')
+            # self("set output '%s'"%file)
+            tmp = 'gnuplot_tmp%s' % file[-4:]
+            self("set output '%s'" % tmp)
+            print("Saving plot to %s" % file)
+            self(cmd)
+            time.sleep(0.1)
+            os.system('mv %s %s 2>/dev/null' % (tmp, file))
+            time.sleep(0.1)
+        self('set terminal x11')
+
+    def plot3d(self, f, xmin=-1, xmax=1, ymin=-1, ymax=1, zmin=-1, zmax=1,
+               title=None,
+               samples=25, isosamples=20, xlabel='x', ylabel='y',
+               interact=True):
+        if title is None:
+            title = str(f)
+        f = f.replace('^', '**')
+        cmd = """
+        set xlabel "%s"
+        set ylabel "%s"
+        set key top
+        set border 4095
+        set xrange [%s:%s]
+        set yrange [%s:%s]
+        set samples %s
+        set isosamples %s
+
+        set title "%s"
+        set pm3d; set palette
+        #show pm3d
+        #show palette
+        splot %s
+        """ % (xlabel, ylabel,
+             xmin, xmax, ymin, ymax,  # zmin, zmax,
+             samples, isosamples,
+             title, f)
+        if interact:
+            self.interact(cmd)
+        else:
+            self(cmd)
+
+    def plot3d_parametric(self, f='cos(u)*(3 + v*cos(u/2)), sin(u)*(3 + v*cos(u/2)), v*sin(u/2)',
+                          range1='[u=-pi:pi]',
+                          range2='[v=-0.2:0.2]', samples=50, title=None,
+                          interact=True):
+        r"""
+        Draw a parametric 3d surface and rotate it interactively.
+
+        INPUT:
+
+        - ``f`` -- string; a function of two variables, e.g.,
+          ``'cos(u)\*(3 + v\*cos(u/2)), sin(u)\*(3 + v\*cos(u/2)), v\*sin(u/2)'``
+
+        - ``range1`` -- string; range of values for one
+          variable, e.g., ``'[u=-pi:pi]'``
+
+        - ``range2`` -- string; range of values for another
+          variable, e.g., ``'[v=-0.2:0.2]'``
+
+        - ``samples`` -- integer; number of sample points to use
+
+        - ``title`` -- string; title of the graph
+
+        EXAMPLES::
+
+            sage: gnuplot.plot3d_parametric('v^2*sin(u), v*cos(u), v*(1-v)')   # optional - gnuplot, not tested (since something pops up)
+        """
+        if title is None:
+            title = str(f)
+        cmd = """
+        set key top
+        set border 4095
+        set samples %s
+
+        set title "%s"
+        set pm3d; set palette; set parametric
+        splot %s %s %s
+        """ % (samples, title, range1, range2, f)
+        cmd = cmd.replace('^', '**')
+        if interact:
+            self.interact(cmd)
+        else:
+            self(cmd)
+
+    def interact(self, cmd):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode='w+t') as f:
+            f.write(cmd + '\n pause -1 "Press return to continue (no further rotation possible)"')
+            os.system(f'gnuplot -persist {f.name}')
+
+    def console(self):
+        gnuplot_console()
+
+
+# An instance
+gnuplot = Gnuplot()
+
+
+def gnuplot_console():
+    from sage.repl.rich_output.display_manager import get_display_manager
+    if not get_display_manager().is_in_terminal():
+        raise RuntimeError('Can use the console only in the terminal. Try %%gnuplot magics instead.')
+    os.system('gnuplot')

sage/interfaces/jmoldata.py

@@ -0,0 +1,208 @@
+# sage_setup: distribution = sagemath-plot
+r"""
+Interface for extracting data and generating images from Jmol readable files.
+
+JmolData is a no GUI version of Jmol useful for extracting data from files Jmol
+reads and for generating image files.
+
+AUTHORS:
+
+- Jonathan Gutow (2012-06-14): complete doctest coverage
+- Jonathan Gutow (2012-03-21): initial version
+"""
+
+# ******************************************************************************
+#       Copyright (C) 2012 Jonathan Gutow (gutow@uwosh.edu)
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ******************************************************************************
+
+from sage.structure.sage_object import SageObject
+
+from sage.features.jmol import JmolDataJar
+from sage.misc.temporary_file import tmp_filename
+from sage.cpython.string import bytes_to_str
+
+import os
+import re
+import subprocess
+from pathlib import Path
+
+
+class JmolData(SageObject):
+    r"""
+    .. TODO::
+
+        Create an animated image file (GIF) if spin is on and put data
+        extracted from a file into a variable/string/structure to return
+    """
+    def __init__(self):
+        """
+        EXAMPLES:
+
+        Create a JmolData object::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+        """
+        pass
+
+    def is_jvm_available(self):
+        """
+        Return ``True`` if the Java Virtual Machine is available and ``False`` if not.
+
+        EXAMPLES:
+
+        Check that it returns a boolean::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+            sage: type(JData.is_jvm_available())
+            <... 'bool'>
+        """
+        try:
+            version = bytes_to_str(subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT))
+        except (subprocess.CalledProcessError, OSError):
+            return False
+
+        java_version_number = int(re.sub(r'.*version "(0\.|1\.)?(\d*)[\s\S]*', r'\2', version, flags=re.S))
+        return java_version_number >= 7
+
+    def jmolpath(self):
+        """
+        Return the path to the jar file.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+            sage: JData.jmolpath()  # needs jmol
+            '.../JmolData.jar'
+        """
+        jmolpath = JmolDataJar().absolute_filename()
+
+        return jmolpath
+
+    def is_jmol_available(self):
+        """
+        Return ``True`` if jmol is available and ``False`` if not.
+
+        EXAMPLES:
+
+        Check that it returns a boolean::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+            sage: type(JData.is_jmol_available())
+            <... 'bool'>
+        """
+        if not JmolDataJar().is_present():
+            return False
+
+        if not self.is_jvm_available():
+            return False
+
+        return True
+
+    def export_image(self,
+                     targetfile,
+                     datafile,  # name (path) of data file Jmol can read or script file telling it what to read or load
+                     datafile_cmd='script',  # "script" or "load"
+                     image_type='PNG',  # PNG, JPG, GIF
+                     figsize=5,
+                     **kwds):
+        r"""
+        This executes JmolData.jar to make an image file.
+
+        INPUT:
+
+        - ``targetfile`` -- the full path to the file where the image
+          should be written
+
+        - ``datafile`` -- full path to the data file Jmol can read or
+          text of a script telling Jmol what to read or load
+
+        - ``datafile_cmd`` -- (default: ``'script'``)  ``'load'`` or ``'script'``
+          should be ``'load'`` for a data file
+
+        - ``image_type`` -- (default: ``"PNG"``) ``'PNG'`` ``'JPG'`` or ``'GIF'``
+
+        - ``figsize`` -- number (default: 5) equal to (pixels/side)/100
+
+        OUTPUT: image file, .png, .gif or .jpg (default: .png)
+
+        .. NOTE::
+
+            Examples will generate an error message if a functional Java Virtual Machine (JVM)
+            is not installed on the machine the Sage instance is running on.
+
+        .. warning::
+
+            Programmers using this module should check that the JVM is
+            available before making calls to avoid the user getting
+            error messages.  Check for the JVM using the function
+            :meth:`is_jvm_available`, which returns ``True`` if a JVM is available.
+
+        EXAMPLES:
+
+        Use Jmol to load a pdb file containing some DNA from a web data
+        base and make an image of the DNA. If you execute this in the
+        notebook, the image will appear in the output cell::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+            sage: script = "load =1lcd;display DNA;moveto 0.0 { -473 -713 -518 59.94} 100.0 0.0 0.0 {21.17 26.72 27.295} 27.544636 {0.0 0.0 0.0} -25.287832 64.8414 0.0;"
+            sage: testfile = tmp_filename(ext="DNA.png")
+            sage: JData.export_image(targetfile=testfile,datafile=script,image_type="PNG")  # optional -- java internet
+            sage: print(os.path.exists(testfile)) # optional -- java internet
+            True
+
+        Use Jmol to save an image of a 3-D object created in Sage.
+        This method is used internally by plot3d to generate static images.
+        This example doesn't have correct scaling::
+
+            sage: from sage.interfaces.jmoldata import JmolData
+            sage: JData = JmolData()
+            sage: D = dodecahedron()                                                    # needs sage.plot
+            sage: from tempfile import NamedTemporaryFile
+            sage: archive = NamedTemporaryFile(suffix='.zip')
+            sage: D.export_jmol(archive.name)                                           # needs sage.plot
+            sage: archive_native = archive.name
+            sage: script  = f'set defaultdirectory "f{archive_native}"\n'
+            sage: script += 'script SCRIPT\n'
+            sage: with NamedTemporaryFile(suffix='.png') as testfile:   # optional - java, needs sage.plot
+            ....:     JData.export_image(targetfile=testfile.name,
+            ....:                        datafile=script,
+            ....:                        image_type="PNG")
+            ....:     os.path.exists(testfile.name)
+            True
+            sage: archive.close()
+        """
+        # Set up paths, file names and scripts
+        jmolpath = self.jmolpath()
+        target_native = targetfile
+
+        launchscript = ""
+        if (datafile_cmd != 'script'):
+            launchscript = "load "
+        launchscript = launchscript + datafile
+
+        imagescript = 'write {} {!r}\n'.format(image_type, target_native)
+        size_arg = "%sx%s" % (figsize * 100, figsize * 100)
+        # Scratch file for Jmol errors
+        scratchout = tmp_filename(ext='.txt')
+        with open(scratchout, 'w') as jout:
+            # Now call the java application and write the file.
+            env = dict(os.environ)
+            env['LC_ALL'] = 'C'
+            env['LANG'] = 'C'
+            subprocess.call(["java", "-Xmx512m", "-Djava.awt.headless=true",
+                             "-jar", jmolpath, "-iox", "-g", size_arg,
+                             "-J", launchscript, "-j", imagescript],
+                            stdout=jout, stderr=jout, env=env)
+        if not os.path.isfile(targetfile):
+            raise RuntimeError(f"Jmol failed to create file {targetfile}: {Path(scratchout).read_text()}")
+        os.unlink(scratchout)

sage/interfaces/povray.py

@@ -0,0 +1,56 @@
+# sage_setup: distribution = sagemath-plot
+r"""
+POV-Ray, The Persistence of Vision Ray Tracer
+"""
+
+from sage.misc.pager import pager
+import os
+
+
+class POVRay:
+    """
+    POV-Ray The Persistence of Vision Ray Tracer
+
+    INPUT:
+
+    - ``pov_file`` -- complete path to the .pov file you want to be rendered
+    - ``outfile`` -- the filename you want to save your result to
+    - ``**kwargs`` -- additionally keyword arguments you want to pass to POVRay
+
+    OUTPUT: image is written to the file you specified in outfile
+
+    EXAMPLES:
+
+    AUTHOR:
+
+    Sage interface written by Yi Qiang (yqiang _atNOSPAM_ gmail.com)
+
+    POVRay: http://www.povray.org
+    """
+    def __repr__(self):
+        return 'POV-Ray The Persistence of Vision Ray Tracer'
+
+    def __call__(self, pov_file, outfile='sage.ppm', block=True, **kwargs):
+        if not os.path.isfile(pov_file):
+            return "%s not found" % (pov_file)
+
+        outfile = os.path.abspath(os.path.expanduser(outfile))
+
+        if not ('W' in kwargs and 'H' in kwargs):
+            return "You must specify a width and height."
+
+        cmd = "povray -D +FP +I%s +O%s " % (pov_file, outfile)
+        for k, v in kwargs.items():
+            cmd += "+%s%s " % (k, v)
+
+        if not block:
+            cmd += ' &'
+        os.system(cmd)
+
+    def usage(self):
+        with os.popen('povray') as f:
+            r = f.read()
+        pager()(r)
+
+
+povray = POVRay()

sage/plot/all.py

@@ -0,0 +1,42 @@
+# sage_setup: distribution = sagemath-plot
+from sage.plot.graphics import Graphics
+from sage.plot.plot import (plot, graphics_array, multi_graphics, list_plot,
+                            parametric_plot, polar_plot, plot_loglog, plot_semilogx,
+                            plot_semilogy, list_plot_loglog, list_plot_semilogx,
+                            list_plot_semilogy)
+from sage.plot.line import line, line2d
+from sage.plot.arrow import arrow, arrow2d
+from sage.plot.bar_chart import bar_chart
+from sage.plot.histogram import histogram
+from sage.plot.bezier_path import bezier_path
+from sage.plot.scatter_plot import scatter_plot
+from sage.plot.disk import disk
+from sage.plot.point import point, points, point2d
+from sage.plot.matrix_plot import matrix_plot
+from sage.plot.plot_field import plot_vector_field, plot_slope_field
+from sage.plot.text import text
+from sage.plot.polygon import polygon, polygon2d
+from sage.plot.circle import circle
+from sage.plot.ellipse import ellipse
+from sage.plot.contour_plot import contour_plot, implicit_plot, region_plot
+from sage.plot.density_plot import density_plot
+from sage.plot.streamline_plot import streamline_plot
+
+from sage.misc.lazy_import import lazy_import
+lazy_import("sage.plot.complex_plot", ["complex_plot"])
+
+from sage.plot.arc import arc
+
+from sage.plot.animate import animate
+
+lazy_import('sage.plot.plot3d.tachyon', 'Tachyon')
+
+from sage.plot.colors import Color, hue, rainbow, colors, colormaps
+
+from sage.plot.step import plot_step_function
+
+lazy_import("sage.plot.hyperbolic_arc", "hyperbolic_arc")
+lazy_import("sage.plot.hyperbolic_polygon", [
+            "hyperbolic_triangle", "hyperbolic_polygon"])
+lazy_import("sage.plot.hyperbolic_regular_polygon", "hyperbolic_regular_polygon")
+del lazy_import