gnuplot 2.3.3 → 2.3.4

data/AUTHORS.txt

@@ -0,0 +1,5 @@
+Gordon James Miller
+Ara T. Howard
+Roger Pack
+Mike Cahill (minor edits)
+jakobs

data/ChangeLog

@@ -0,0 +1,51 @@
+2.3.4
+ * Include more files in the gem by switching to Jeweler (thanks Jeweler guyz)!
+
+2.3.3
+ * Fix issue #4 (thanks Jakobs)
+ * Fix some unit tests (thanks Nobu!) 
+
+2.3.2 Feb 2010
+ * Add an arbitrary_lines specifier
+
+2.3.1 Feb 2010
+
+* Fix a bug I introduced in 2.3.0
+
+2.3.0 Feb 2010
+
+* incorporate a few patch changes
+
+2.2.3.1 July 18 2009
+	
+* output the raw "to gnuplot" data if $VERBOSE
+
+Version 2.2.2 July 2009
+
+* raise if no executable found, should be windows compat. now
+
+Version 2.2  14-Nov-2005
+
+* Formally added the LICENSE.txt file.  It is the new BSD license as defined
+  by opensource.org.  See that file for details.
+
+* Added Gnuplot.which to try and fix the recurring problem of windows users
+  having to hack code to get things working.
+
+* Added the Gnuplot.gnuplot function so that I can unit test the finding
+  gnuplot executable routine.
+
+* In the Array.to_gplot method the terminating e is added to the output.  This
+  is in response to Bug #2209.
+
+Version 2.1  17-Nov-2004
+
+* Array.to_gplot and Array.to_gsplot now support passing in arrays of
+  arbitrary objects. This is in response to a request by Yoshiki Tsunesada
+  (Tracker ID 1063)
+
+Version 2.0   10-Nov-2004
+
+* The 2.0 version of the gnuplot interface is a cross between the original,
+  object oriented version, and the version 1.0 which was simply a string
+  manipulation library.

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2004-2005, Gordon James Miller (gmiller@bittwiddlers.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the BitTwiddlers, Inc. nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.textile

@@ -0,0 +1,234 @@
+h1.  Ruby Gnuplot - How To 
+
+p=. 
+      ["Rubyforge Project
+	page":http://rubyforge.org/projects/rgplot]
+      ["ChangeLog":ChangeLog]
+      ["Authors":AUTHORS.txt]
+      ["License":LICENSE.txt]
+    
+h2.  History and Background 
+
+      Gnuplot is a program that has a rich language for the generation of
+      plots.  It has a unique place in academia as it was one of the first
+      freely available programs for plot generation.  I started using gnuplot
+      over 10 years ago while pursuing my Master's degree in Physics and have
+      been using it actively ever since.
+    
+h3. Version 0.9 
+
+bq. 
+      My first attempt at a Ruby interface to gnuplot was an object interface
+      encapsulating gnuplot language. This was taken directly from the Python
+      gnuplot interface. In spite of my being very familiar with Gnuplot and
+      Ruby and being the author of the RGnuplot package, I found it
+      non-intuitive to use the RGnuplot package.  I found myself constantly
+      looking at the code to figure out what I needed to do.
+      This was not sufficient and did not sit well.
+    
+h3. Version 1.0
+
+bq. 
+      The second attempt at a Ruby interface was to do absolutely nothing but
+      use Ruby's built in string manipulation methods.  This meant that I
+      could simply use my knowledge of Gnuplot without having to worry about
+      objects.
+      While in some ways an improvement over Version 0.9, it still did not sit
+      well with me.
+    
+h3.  Version 2.0 
+
+bq. 
+      After attending RubyConf 2004 I was inspired by Rich Kilmer's use of
+      Ruby to implement domain specific languages.  That is the current
+      implementation of Gnuplot and quite probably the one that I'll stick
+      with for some time.  This version combines the direct mapping of the
+      gnuplot language without wrapping with the ruby syntax and mechanism of
+      adding methods to existing classes to interface Ruby objects with
+      gnuplot.
+    
+h2. Setup 
+
+h3. Version 2.2
+
+    If the 'gnuplot' command is in your path then there is no required
+    setup. If the gnuplot executable for your system is called something other
+    than simply 'gnuplot' then set the RB_GNUPLOT environment variable to the
+    name of the executable.  This must either be a full path to the gnuplot
+    command or an executable filename that exists in your PATH environment
+    variable.
+    
+h2.  Ruby Gnuplot Concepts 
+
+      Gnuplot has a very simple conceptual model.  Calls to _Set_ are
+      made to set parameters and either _Plot_ or _Splot_ is
+      called to generate the actual plot.  The _dataset_ to be 
+      plotted can be specified in a number of ways, contained in a seperate
+      file, generated from a function, read from standard input, or read
+      immediately after the plot command.
+    
+
+      The object model for the Ruby gnuplot wrapper directly mimics this
+      layout and flow.  The following are the standard steps for generating a
+      plot:
+    
+    
+p.  Instantiate a Plot or Splot object and set parameters by gnuplot variable name. 
+p. Instantiate DataSet objects and attach Ruby objects containing
+	  the data to be plotted to the DataSet. Attach properties that modify
+	  the plot command using the modifier name.
+      
+p. Send the Plot/Splot object to a Gnuplot instance for
+	  plotting.  
+
+      The Version 2.0 interface makes very heavy use of blocks leading to very
+      readable code.
+    
+Gnuplot.open 
+
+
+      Instantiates a new Gnuplot process.  The path to the executable is
+      determined on a Unix or MacOSX system using the which command.  Windows
+      users, I have no idea what to do.
+      If a block is given to the function the opened process is passed into
+      the block.  This mimics the most common usage of the File.open method.
+    
+Plot.new 
+
+
+ 
+bq. 
+      Create a new Plot or Splot object.  DataSets are attached to the object
+      to specify the data and its properties. 
+      If a block is given to the function, the plot object is passed into the
+      block.
+    
+DataSet.new
+
+bq. 
+      Associates a Ruby object containing the data to plot with the properties
+      that will be passed to the plot command for that dataset.  Any Ruby
+      object can be associated with a DataSet as long as it understands the
+      to_gplot method.
+    
+ to_gplot 
+ 
+bq. 
+      Within Gnuplot, plot data is read in very simple formats.  The
+      to_gplot method is expected to write the data of the object in a format
+      that is understandable by Gnuplot.  One of the many great things about
+      Ruby is that methods can be added after the original declaration.  The
+      gnuplot module defines the to_gplot method on the following classes:
+      Array, String, and Matrix.
+      Simply define a to_gplot method on your own class to tie the class into
+      gnuplot.
+    
+h2.  Examples 
+
+
+
+bq. The following example simply plots the value of sin(x) between the
+      ranges of -10 and 10.  A few points to notice:
+    
+    
+p.  The code uses nested blocks to construct the plot.  The newly
+	  created object is passed to the block so it can be modified in
+	  place.
+	
+      
+p.  Each of the gnuplot plot variables are modified using the 
+	  variable name as a method name on the plot object or on the dataset
+	  object.  The wrapper also takes care of the single quoting that is
+	  required on some of the variables like title, ylabel, and xlabel.
+	
+      
+p.  The plot object simply has an array of DataSets.  The
+	  constructor initializes this empty array before yielding to the
+	  block.  This method uses the << operator to add the DataSet to
+	  the plot.
+	
+      
+p.  When the plot block ends, if an IO object is given to the Plot
+	  constructor, the plot commands will be written to the IO object.
+	  Any object can be passed to the constructor as long as it
+	  understands the << operator.
+	  
+<pre><code>
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.xrange "[-10:10]"
+    plot.title  "Sin Wave Example"
+    plot.ylabel "x"
+    plot.xlabel "sin(x)"
+    
+    plot.data << Gnuplot::DataSet.new( "sin(x)" ) do |ds|
+      ds.with = "lines"
+      ds.linewidth = 4
+    end
+    
+  end
+  
+end
+
+
+
+Array data can be plotted quite easily since Arrays have a defined to_gplot method.
+
+Simply pass an array of data to the constructor of the DataSet object or set the data property of the DataSet. In this example, because there are two arrays, each array will be a single column of data to the gnuplot process.
+
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.title  "Array Plot Example"
+    plot.ylabel "x"
+    plot.xlabel "x^2"
+    
+    x = (0..50).collect { |v| v.to_f }
+    y = x.collect { |v| v ** 2 }
+
+    plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+      ds.with = "linespoints"
+      ds.notitle
+    end
+  end
+end
+    
+Multiple Data Sets
+
+As many data sets as are desired can be attached to a plot. Each of these can have their own plot modifiers. Notice in this example how the data array is explicitly set instead of using the << operator.
+
+Also in this example, the commands are not written to the Gnuplot process but are instead written to a File called gnuplot.dat. This file can later be run directly by a gnuplot process as it contains only the gnuplot commands.
+
+File.open( "gnuplot.dat", "w") do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.xrange "[-10:10]"
+    plot.title  "Sin Wave Example"
+    plot.ylabel "x"
+    plot.xlabel "sin(x)"
+    
+    x = (0..50).collect { |v| v.to_f }
+    y = x.collect { |v| v ** 2 }
+
+    plot.data = [
+      Gnuplot::DataSet.new( "sin(x)" ) { |ds|
+        ds.with = "lines"
+        ds.title = "String function"
+    	  ds.linewidth = 4
+      },
+    
+      Gnuplot::DataSet.new( [x, y] ) { |ds|
+        ds.with = "linespoints"
+        ds.title = "Array data"
+      }
+    ]
+
+  end
+  
+end
+    
+
+You can also add atribtrary lines to the output 
+
+plot.arbitrary_lines << "set ylabel \"y label" font \"Helvetica,20\""

data/Rakefile

@@ -0,0 +1,9 @@
+require 'jeweler'
+Jeweler::Tasks.new do |s|
+  s.name = 'gnuplot'
+  s.description = s.summary = "Utility library to aid in interacting with gnuplot"
+  s.version = "2.3.4"
+  s.autorequire = 'gnuplot.rb'
+  s.email = "rogerpack2005@gmail.com"
+  s.homepage = "http://github.com/rdp/ruby_gnuplot/tree/master"
+end

data/test/arrtest.rb

@@ -0,0 +1,21 @@
+require '../lib/gnuplot'
+
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.title  "Array Plot Example"
+    plot.ylabel "x"
+    plot.xlabel "x^2"
+    
+    x = (0..50).collect { |v| v.to_f }
+    y = x.collect { |v| v ** 2 }
+
+    plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+      ds.with = "linespoints"
+      ds.notitle
+    end
+    
+  end
+  
+end
+    

data/test/histtest.rb

@@ -0,0 +1,20 @@
+require '../lib/gnuplot'
+
+Gnuplot.open do |gp|
+    gp << "bin(x, s) = s*int(x/s)\n"
+
+    Gnuplot::Plot.new( gp ) do |plot|
+	plot.title  "Histogram"
+	plot.xlabel "x"
+	plot.ylabel "frequency"
+
+	x = (0..500).collect { |v| (rand()-0.5)**3 }
+	plot.data << Gnuplot::DataSet.new( [x] ) do |ds|
+	    ds.title = "smooth frequency" 
+	    ds.using = "(bin($1,.01)):(1.)"
+	    ds.smooth = "freq"
+	    ds.with = "boxes"
+	end
+    end
+end
+

data/test/multtest.rb

@@ -0,0 +1,31 @@
+require '../lib/gnuplot'
+
+# File.open( "gnuplot.dat", "w") do |gp|
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.xrange "[-10:10]"
+    plot.title  "Sin Wave Example"
+    plot.ylabel "x"
+    plot.xlabel "sin(x)"
+    
+    x = (0..50).collect { |v| v.to_f }
+    y = x.collect { |v| v ** 2 }
+
+    plot.data = [
+      Gnuplot::DataSet.new( "sin(x)" ) { |ds|
+	ds.with = "lines"
+	ds.title = "String function"
+	ds.linewidth = 4
+      },
+    
+      Gnuplot::DataSet.new( [x, y] ) { |ds|
+	ds.with = "linespoints"
+	ds.title = "Array data"
+      }
+    ]
+
+  end
+  
+end
+    

data/test/sinwave.rb

@@ -0,0 +1,19 @@
+require '../lib/gnuplot'
+
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+  
+    plot.xrange "[-10:10]"
+    plot.title  "Sin Wave Example"
+    plot.ylabel "x"
+    plot.xlabel "sin(x)"
+    
+    plot.data << Gnuplot::DataSet.new( "sin(x)" ) do |ds|
+      ds.with = "lines"
+      ds.linewidth = 4
+    end
+    
+  end
+  
+end
+    

data/test/test_gnuplot.rb

@@ -0,0 +1,120 @@
+# -*- ruby -*-
+
+require '../lib/gnuplot'
+require 'test/unit'
+
+class StdDataTest < Test::Unit::TestCase
+    
+  def test_array_1d
+    data = (0..5).to_a
+    ds = Gnuplot::DataSet.new( data )
+    
+    assert data == ds.data
+    assert data.join("\n") + "\n", ds.to_gplot
+  end
+
+
+  # Test a multidimensional array.
+
+  def test_array_nd
+    d1 = (0..3).to_a
+    d2 = d1.collect { |v| 3 * v }
+    d3 = d2.collect { |v| 4 * v }
+    
+    data = [ d1, d2, d3 ]
+    ds = Gnuplot::DataSet.new( data )
+    
+    assert data == ds.data
+    assert "0 0 0\n1 3 12\n2 6 24\n3 9 36\n", ds.to_gplot
+  end
+end
+
+
+class DataSetTest < Test::Unit::TestCase
+
+  def test_yield_ctor
+    ds = Gnuplot::DataSet.new do |ds|
+      ds.with = "lines" 
+      ds.using = "1:2"
+      ds.data = [ [0, 1, 2], [1, 2, 5] ]
+    end
+    
+    assert "lines", ds.with
+    assert "1:2",   ds.using
+    assert nil == ds.title
+    assert [ [0, 1, 2], [1, 2, 5] ] == ds.data
+    assert "'-' using 1:2 with lines",  ds.plot_args
+    assert "0 1\n1 2\n2 5\n", ds.to_gplot 
+  end
+  
+end
+
+
+class PlotTest < Test::Unit::TestCase
+  
+  def test_no_data
+    plot = Gnuplot::Plot.new do |p|
+      p.set "output", "'foo'"
+      p.set "terminal", "postscript enhanced"
+    end
+
+    assert( plot.sets ==
+		 [ ["output", "'foo'"], 
+		   ["terminal", "postscript enhanced"] ] )
+    
+
+    assert( plot.to_gplot, \
+		 "set output 'foo'\nset terminal postscript enhanced\n" )
+
+  end
+
+  def test_set
+    plot = Gnuplot::Plot.new do |p|
+      p.set "title", "foo"
+    end
+    assert "'foo'", plot["title"]
+
+    plot.set "title", "'foo'"
+    assert "'foo'", plot["title"]
+  end
+
+end
+
+
+require 'rbconfig'
+CONFIG = Config::MAKEFILE_CONFIG
+
+# This attempts to test the functions that comprise the gnuplot package.  Most
+# of the bug reports that I get for this package have to do with finding the
+# gnuplot executable under different environments so that makes it difficult
+# to test on a single environment.  To try to get around this I'm using the
+# rbconfig library and its path to the sh environment variable.
+
+class GnuplotModuleTest
+
+  def test_which
+    # Put the spaces around the command to make sure that it gets stripped
+    # properly. 
+    assert( CONFIG["SHELL"], Gnuplot::which(" sh " ) )
+    assert( CONFIG["SHELL"], Gnuplot::which( CONFIG["SHELL"] ) )
+  end
+
+
+  def test_gnuplot
+    cmd = Gnuplot.gnuplot
+    assert( Gnuplot::which("gnuplot") + " -persist", cmd )
+
+    cmd = Gnuplot.gnuplot(false)
+    assert( Gnuplot::which("gnuplot"), cmd )
+
+    # If I set the name of the gnuplot environment variable to a different
+    # name (one that is in the path) then I should get the shell name as the
+    # result of the gnuplot call.
+
+    ENV["RB_GNUPLOT"] = "sh" 
+    assert( CONFIG["SHELL"], Gnuplot.gnuplot(false) )
+  end
+      
+end
+
+

metadata

@@ -5,16 +5,16 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 3
-  - 3
-  version: 2.3.3
+  - 4
+  version: 2.3.4
 platform: ruby
-authors: 
-- see AUTHORS.txt
+authors: []
+
 autorequire: gnuplot.rb
 bindir: bin
 cert_chain: []
 
-date: 2010-07-30 00:00:00 -06:00
+date: 2010-08-02 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -24,17 +24,29 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- ChangeLog
+- LICENSE.txt
+- README.textile
 files: 
+- AUTHORS.txt
+- ChangeLog
+- LICENSE.txt
+- README.textile
+- Rakefile
 - lib/gnuplot.rb
+- test/arrtest.rb
+- test/histtest.rb
+- test/multtest.rb
+- test/sinwave.rb
+- test/test_gnuplot.rb
 has_rdoc: true
 homepage: http://github.com/rdp/ruby_gnuplot/tree/master
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -60,5 +72,9 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Utility library to aid in interacting with gnuplot
-test_files: []
-
+test_files: 
+- test/arrtest.rb
+- test/histtest.rb
+- test/multtest.rb
+- test/sinwave.rb
+- test/test_gnuplot.rb