Gnuplot.py version 1.5 released

[Michael Haggerty]

This is to announce the release of version 1.5 of Gnuplot.py.

[This is the first release of Gnuplot.py in over a year.  I had been
very busy with a job in a startup in which I didn't need the package.
Now that my company is a dot.bust, I have had a little time to catch
up on Gnuplot.py (and other free software) development while I look
for new consulting work.]

Gnuplot.py is a Python [1] package that allows you to create graphs
from within Python using the gnuplot [2] plotting program.

Gnuplot.py can be obtained from

    http://gnuplot-py.sourceforge.net/

Prerequisites (see footnotes):
    the Python interpreter [1]
    the Python Numeric module [3]
    the gnuplot program [2]

Some ways this package can be used:

1. Interactive data processing: Use Python's excellent Numeric package
   to create and manipulate arrays of numbers, and use Gnuplot.py to
   visualize the results.
2. Web graphics: write CGI scripts in Python that use gnuplot to
   output plots in GIF format and return them to the client.
3. Glue for numerical applications (this is my favorite): wrap your
   C++/C/Fortran subroutines so that they are callable from Python,
   then you can perform numerical computations interactively from
   scripts or from the command line and use Gnuplot.py to plot the
   output on the fly.
4. Compute a series of datasets in Python and plot them one after the
   other using Gnuplot.py to produce a crude animation.

New features in this version:

  +  Added distutils support.
  +  Broke up the module a bit for better maintainability.  The most
     commonly-used facilities are still available through "import
     Gnuplot", but some specialized things have been moved to separate
     modules, in particular funcutils.py and PlotItems.py.
  +  funcutils.tabulate_function() can be used to evaluate a function
     on a 1-D or 2-D grid of points (this replaces grid_function,
     which only worked with 2-D grids).
  +  Added two helper functions, funcutils.compute_Data and
     funcutils.compute_GridData, which compute a function's values on
     a set of points and package the results into a PlotItem.
  +  GridFunc is no longer an independent class; it is now a factory
     function that returns a GridData.  GridFunc is deprecated in
     favor of funcutils.compute_GridData.
  +  Changed set_option to work from a table, so that it doesn't need
     to be overloaded so often.
  +  Implemented test_persist for each platform to make it easier for
     users to determine whether the `-persist' option is supported.
  +  Added a prefer_persist option to serve as the default `persist'
     choice.
  +  Following a suggestion by Jannie Hofmeyr, use "from os import
     popen" for Python 2.0 under Windows.  I don't use Windows, so let
     me know how this works.
  +  Added support for the `axes' and `smooth' options of the `plot'
     command.
  +  Reworked the comment strings in an effort to make them work
     nicely with happydoc.

Features already present in older versions:

  +  Two and three-dimensional plots.
  +  Plot data from memory, from a file, or from an expression.
  +  Support for multiple simultaneous gnuplot sessions.
  +  Can pass arbitrary commands to the gnuplot program.
  +  Object oriented, extensible design with several built-in types
     of plot items.
  +  Portable and easy to install (nothing to compile except on
     Windows).
  +  Support for MS Windows, using the `pgnuplot.exe' program.
  +  Support for sending data to gnuplot as `inline' or `binary' data.
     These are optimizations that also remove the need for temporary
     files.  Temporary files are still the default.


Footnotes:
----------
[1] Python <http://www.python.org> is an excellent object-oriented
    scripting/rapid development language that is also especially good
    at gluing programs together.
[2] gnuplot <http://www.gnuplot.org/> is a free, popular, very
    portable plotting program with a command-line interface.  It can
    make 2-d and 3-d plots and can output to myriad printers and
    graphics terminals.
[3] The Numeric Python extension <http://numpy.sourceforge.net/> is a
    Python module that adds fast and convenient array manipulations to
    the Python language.

Yours,
Michael

-- 
Michael Haggerty
mhagger at alum.mit.edu