blackwinter-gnuplot 2.3.5.1

data/AUTHORS.txt

@@ -0,0 +1,7 @@
+Gordon James Miller
+Ara T. Howard
+Roger Pack
+Mike Cahill
+jakobs
+blambeau
+Jens Wille

data/ChangeLog

@@ -0,0 +1,54 @@
+2.3.5
+ * Cleanup readme, add examples as real code files (thanks blambeau!)
+
+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.rdoc

@@ -0,0 +1,203 @@
+= Ruby Gnuplot - Utility library to aid in interacting with GNUPLOT
+
+* {Rubyforge Project page}[http://rubyforge.org/projects/rgplot]
+* {Documentation}[http://blackwinter.github.com/ruby_gnuplot]
+* {Source code}[http://github.com/blackwinter/ruby_gnuplot]
+
+
+== History and Background
+
+GNUPLOT[http://gnuplot.info] 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.
+
+=== Version 0.9
+
+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.
+
+=== Version 1.0
+
+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.
+
+=== Version 2.0
+
+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.
+
+
+== Setup
+
+=== 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.
+
+
+== 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 separate 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:
+
+* Instantiate a Gnuplot::Plot or Gnuplot::SPlot object and set parameters by
+  GNUPLOT variable name.
+* Instantiate Gnuplot::DataSet objects and attach Ruby objects containing the
+  data to be plotted to the data set.
+* Attach properties that modify the plot command using the modifier name.
+* Send the Plot/SPlot object to a GNUPLOT instance for plotting.
+
+The version 2.0 interface makes heavy use of blocks leading to very readable
+code.
+
+[<tt>Gnuplot.open</tt>]
+  Instantiates a new GNUPLOT process. The path to the executable is determined
+  using the Gnuplot.which command.  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.
+
+[<tt>Gnuplot::Plot.new</tt>, <tt>Gnuplot::SPlot.new</tt>]
+  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.
+
+[<tt>Gnuplot::DataSet.new</tt>]
+  Associates a Ruby object containing the data to plot with the properties
+  that will be passed to the plot command for that data set. Any Ruby object
+  can be associated with a DataSet as long as it understands the +to_gplot+
+  method.
+
+[<tt>to_gplot</tt>]
+  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 classes Array and Matrix. Simply
+  define a +to_gplot+ method on your own class to tie the class into gnuplot.
+
+
+== Examples
+
+=== Simple sine wave
+
+The following example simply plots the value of <tt>sin(x)</tt> between the
+ranges of -10 and 10. A few points to notice:
+
+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.
+
+Each of the GNUPLOT plot variables is modified using the variable name as a
+method name on the plot object or on the data set object. The wrapper also
+takes care of the single quoting that is required on some of the variables
+like +title+, +ylabel+, and +xlabel+.
+
+The plot object simply has an array of Gnuplot::DataSet objects. The
+constructor initializes this empty array before yielding to the block. This
+method uses the <tt><<</tt> operator to add the DataSet to the plot.
+
+When the plot block ends, if an IO object is given to the Gnuplot::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 <tt><<</tt> operator.
+
+  Gnuplot.open { |gp|
+    Gnuplot::Plot.new(gp) { |plot|
+
+      plot.xrange '[-10:10]'
+      plot.title  'Sine Wave Example'
+      plot.xlabel 'x'
+      plot.ylabel 'sin(x)'
+
+      plot.data << Gnuplot::DataSet.new('sin(x)') { |ds|
+        ds.with = 'lines'
+        ds.linewidth = 4
+      }
+
+    }
+  }
+
+=== Plotting discrete points
+
+Array data can be plotted quite easily since Arrays have a defined
+Array#to_gplot method.
+
+Simply pass an array of data to the constructor of the Gnuplot::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.
+
+Also, this example uses the Gnuplot.plot convenience method which wraps
+the calls to Gnuplot.open and Gnuplot::Plot.new.
+
+  Gnuplot.plot { |plot|
+    plot.title  'Array Plot Example'
+    plot.xlabel 'x'
+    plot.ylabel 'x^2'
+
+    x = (0..50).map { |v| v.to_f }
+    y = x.map { |v| v ** 2 }
+
+    plot.data << Gnuplot::DataSet.new([x, y]) { |ds|
+      ds.with = 'linespoints'
+      ds.notitle
+    }
+  }
+
+=== 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
+set through the Gnuplot::DataSet#data convenience method instead of using the
+<tt><<</tt> operator.
+
+Also in this example, the commands are not written to the GNUPLOT process but
+are instead written to a File called <tt>gnuplot.dat</tt>. This file can later
+be run directly by a GNUPLOT process as it contains only the GNUPLOT commands.
+
+  Gnuplot.plot_to('gnuplot.dat') { |plot|
+    plot.xrange '[-10:10]'
+    plot.title  'Sin Wave Example'
+    plot.xlabel 'x'
+    plot.ylabel 'sin(x)'
+
+    x = (0..50).map { |v| v.to_f }
+    y = x.map { |v| v ** 2 }
+
+    plot.data('sin(x)') { |ds|
+      ds.with = 'lines'
+      ds.title = 'String function'
+      ds.linewidth = 4
+    }
+
+    plot.data([x, y]) { |ds|
+      ds.with = 'linespoints'
+      ds.title = 'Array data'
+    }
+  }
+
+You can also add arbitrary lines to the output:
+
+  plot.arbitrary_lines << 'set ylabel "y label" font "Helvetica,20"'
+
+  # or more conveniently
+  plot << 'set ylabel "y label" font "Helvetica,20"'

data/Rakefile

@@ -0,0 +1,32 @@
+require File.expand_path(%q{../lib/gnuplot/version}, __FILE__)
+
+require 'jeweler'
+require 'rdoc/task'
+require 'rake/testtask'
+
+Jeweler::Tasks.new { |s|
+  s.name     = 'blackwinter-gnuplot'
+  s.version  = Gnuplot::VERSION
+  s.summary  = 'Utility library to aid in interacting with GNUPLOT'
+  s.authors  = ['Roger Pack', 'Jens Wille']
+  s.email    = ['rogerpack2005@gmail.com', 'jens.wille@uni-koeln.de']
+  s.homepage = 'http://github.com/blackwinter/ruby_gnuplot'
+
+  s.add_dependency 'ruby-nuggets'
+}
+
+RDoc::Task.new(:doc) { |t|
+  t.rdoc_dir   = 'doc'
+  t.rdoc_files = FileList[
+    'lib/**/*.rb', 'README.rdoc', 'ChangeLog', 'AUTHORS.txt', 'LICENSE.txt'
+  ].to_a
+  t.options    = [
+    '--title', "Gnuplot Application documentation (v#{Gnuplot::VERSION})",
+    '--main', 'README.rdoc', '--charset', 'UTF-8', '--line-numbers', '--all'
+  ]
+}
+
+Rake::TestTask.new { |t|
+  t.test_files = FileList['test/**/test_*.rb'].to_a
+  t.ruby_opts << '-rubygems'
+}

data/examples/.gitignore

@@ -0,0 +1 @@
+sine_wave_example*.*

data/examples/discrete_points.rb

@@ -0,0 +1,15 @@
+require 'gnuplot'
+
+Gnuplot.plot { |plot|
+  plot.title  'Discrete Points Example'
+  plot.xlabel 'x'
+  plot.ylabel 'x^2'
+
+  x = (0..50).map { |v| v.to_f }
+  y = x.map { |v| v ** 2 }
+
+  plot.data([x, y]) { |ds|
+    ds.with = 'linespoints'
+    ds.notitle
+  }
+}

data/examples/histogram.rb

@@ -0,0 +1,18 @@
+require 'gnuplot'
+
+Gnuplot.plot { |plot|
+  plot.title  'Histogram Example'
+  plot.xlabel 'x'
+  plot.ylabel 'frequency'
+
+  plot << 'bin(x, s) = s*int(x/s)'
+
+  x = (0..500).map { |v| (rand - 0.5) ** 3 }
+
+  plot.data([x]) { |ds|
+    ds.title  = 'smooth frequency'
+    ds.using  = '(bin($1,.01)):(1.)'
+    ds.smooth = 'freq'
+    ds.with   = 'boxes'
+  }
+}

data/examples/multiple_data_sets.rb

@@ -0,0 +1,22 @@
+require 'gnuplot'
+
+Gnuplot.plot { |plot|
+  plot.xrange '[-10:10]'
+  plot.title  'Multiple Data Sets Example'
+  plot.xlabel 'x'
+  plot.ylabel 'y'
+
+  x = (0..50).map { |v| v.to_f }
+  y = x.map { |v| v ** 2 }
+
+  plot.data('sin(x)') { |ds|
+    ds.with      = 'lines'
+    ds.title     = 'String function'
+    ds.linewidth = 4
+  }
+
+  plot.data([x, y]) { |ds|
+    ds.with  = 'linespoints'
+    ds.title = 'Array data'
+  }
+}

data/examples/output_file1.rb

@@ -0,0 +1,26 @@
+require 'gnuplot'
+
+file = File.expand_path('../output_file_example1.gif', __FILE__)
+
+Gnuplot.plot { |plot|
+  # The following lines allow outputting the graph to an image file.
+  # The first sets the kind of image that you want, while the second
+  # redirects the output to a given file.
+  #
+  # Typical terminals: gif, png, postscript, latex, texdraw
+  #
+  # See http://mibai.tec.u-ryukyu.ac.jp/~oshiro/Doc/gnuplot_primer/gptermcmp.html
+  # for a list of recognized terminals.
+  plot.terminal 'gif'
+  plot.output   file
+
+  plot.xrange '[-10:10]'
+  plot.title  'Sine Wave Example'
+  plot.xlabel 'x'
+  plot.ylabel 'sin(x)'
+
+  plot.data('sin(x)') { |ds|
+    ds.with      = 'lines'
+    ds.linewidth = 4
+  }
+}

data/examples/output_file2.rb

@@ -0,0 +1,15 @@
+require 'gnuplot'
+
+file = File.expand_path('../output_file_example2.dat', __FILE__)
+
+Gnuplot.plot_to(file) { |plot|
+  plot.xrange '[-10:10]'
+  plot.title  'Sine Wave Example'
+  plot.xlabel 'x'
+  plot.ylabel 'sin(x)'
+
+  plot.data('sin(x)') { |ds|
+    ds.with      = 'lines'
+    ds.linewidth = 4
+  }
+}

data/examples/sine_wave.rb

@@ -0,0 +1,13 @@
+require 'gnuplot'
+
+Gnuplot.plot { |plot|
+  plot.xrange '[-10:10]'
+  plot.title  'Sine Wave Example'
+  plot.xlabel 'x'
+  plot.ylabel 'sin(x)'
+
+  plot.data('sin(x)') { |ds|
+    ds.with = 'lines'
+    ds.linewidth = 4
+  }
+}

data/lib/gnuplot/version.rb

@@ -0,0 +1,5 @@
+module Gnuplot
+
+  VERSION = '2.3.5.1'
+
+end

data/lib/gnuplot.rb

@@ -0,0 +1,332 @@
+require 'matrix'
+require 'nuggets/file/which'
+
+# Methods and variables for interacting with the GNUPLOT process. Most of
+# these methods are for sending data to a GNUPLOT process, not for reading
+# from it. Some of the methods are implemented as added methods to the built
+# in classes.
+
+module Gnuplot
+
+  # Holds the map of file extensions to GNUPLOT terminals.
+  TERMINAL = Hash.new { |h, k| h[k] = k }.update(
+    'dat' => nil,
+    'jpg' => 'jpeg',
+    'ps'  => 'postscript'
+  )
+
+  class << self
+
+    attr_writer :gnuplot
+
+    # Maps file extension (with optional dot) to GNUPLOT terminal (cf.
+    # TERMINAL).
+    def terminal(ext)
+      TERMINAL[ext.to_s.sub(/\A\./, '')]
+    end
+
+    # Delegates to File.which, but String#strip's +bin+ first.
+    def which(bin)
+      File.which(bin.strip)
+    end
+
+    # Finds the path to the GNUPLOT executable. The name of the executable
+    # can be specified using the link:#gnuplot= accessor or the RB_GNUPLOT
+    # environment variable but will default to the command +gnuplot+.
+    #
+    # Adds the persist flag to the GNUPLOT executable if +persist+ is +true+.
+    #
+    # Returns the path to the GNUPLOT executable or raises an error if one
+    # cannot be found.
+    def gnuplot(persist = true)
+      @gnuplot ||= which(ENV['RB_GNUPLOT'] || 'gnuplot')
+      raise 'GNUPLOT executable not found' unless @gnuplot
+
+      "#{@gnuplot}#{' -persist' if persist}"
+    end
+
+    # Opens a GNUPLOT process via Gnuplot.gnuplot (passing the +persist+ flag) and
+    # yields the IO object associated with the GNUPLOT process to the block.
+    #
+    # See the {GNUPLOT documentation}[http://gnuplot.sourceforge.net/documentation.html]
+    # for information on the persist flag.
+    def open(persist = true, mode = 'w')
+      IO.popen(gnuplot(persist), mode) { |gp| yield gp }
+    end
+
+    # Wraps the calls to Gnuplot.open and Gnuplot::Plot.new.
+    def plot(persist = true, *args, &block)
+      open(persist) { |gp| Plot.new(gp, *args, &block) }
+    end
+
+    # If +file+ is a file name that has a Gnuplot.terminal associated with it,
+    # the GNUPLOT process's terminal will be set accordingly and its output
+    # redirected to +file+.
+    #
+    # If +file+ is an IO object or doesn't have a terminal associated with it,
+    # the GNUPLOT process's output will simply be written to +file+.
+    def plot_to(file, persist = false, *args, &block)
+      io, file = file, nil if file.respond_to?(:write)
+
+      if file and term = terminal(File.extname(file))
+        plot(persist, *args) { |plot|
+          block[plot]
+
+          plot.terminal term unless plot[:terminal] || plot[:term]
+          plot.output file.to_s unless plot[:output] || plot[:out]
+        }
+      else
+        begin
+          io ||= File.open(file, 'w')
+          Plot.new(io, *args, &block)
+        ensure
+          io.close if file && io
+        end
+      end
+    end
+
+  end
+
+  # Holds command information and performs the formatting of that command
+  # information to a GNUPLOT process. When constructing a new plot for
+  # GNUPLOT, this is the first object that must be instantiated. On this
+  # object set the various properties and add data sets.
+
+  class Plot
+
+    QUOTED = %w[title output xlabel ylabel]
+
+    attr_accessor :io, :cmd, :data, :sets, :arbitrary_lines
+
+    def initialize(io = nil, cmd = 'plot')
+      @io, @cmd, @data, @sets, @arbitrary_lines = io, cmd, [], [], []
+
+      yield self if block_given?
+
+      plot! if io
+    end
+
+    # Sends the data and commands to the GNUPLOT process, drawing the plot.
+    #
+    # Prints the plot commands that are sent to the GNUPLOT process to +io+
+    # if +verbose+ is +true+.
+    def plot!(verbose = $VERBOSE, io = $stderr)
+      if verbose && io
+        io << "Writing this to GNUPLOT:\n"
+        to_gplot(io)
+      end
+
+      to_gplot
+    end
+
+    # Invoke the set method on the plot using the name of the invoked method
+    # as the set variable and any arguments that have been passed as the
+    # value. See the #set method for more details.
+    def method_missing(method, *args)
+      set(method, *args)
+    end
+
+    # Set a variable to the given +value+. +var+ must be a GNUPLOT variable
+    # and +value+ must be the value to set it to. Automatic quoting will be
+    # performed if the variable requires it (see QUOTED).
+    def set(var, value = '')
+      var   = var.to_s
+      value = %Q{"#{value}"} if QUOTED.include?(var) && value !~ /\A'.*'\z/
+
+      @sets << [var, value]
+    end
+
+    alias_method :[]=, :set
+
+    # Return the current value of the GNUPLOT variable +var+. This will
+    # return the setting that is currently in the instance, not one that's
+    # been given to the GNUPLOT process.
+    def [](var)
+      assoc = @sets.assoc(var.to_s)
+      assoc.last if assoc
+    end
+
+    # If +args+ is non-empty or +block+ is given, calls #add_data. Returns
+    # the current data otherwise.
+    def data(*args, &block)
+      args.empty? && !block ? @data : add_data(*args, &block)
+    end
+
+    # Adds the DataSet +data+ to the GNUPLOT process's data sets. If +data+
+    # is not already a DataSet object, DataSet.new will be called with +data+
+    # and +block+ as arguments.
+    def add_data(data = nil, &block)
+      @data.push(data.is_a?(DataSet) ? data : DataSet.new(data, &block))
+    end
+
+    # Adds an arbitrary +line+ to write to the GNUPLOT process. Returns +self+
+    # to allow chaining.
+    def <<(line)
+      @arbitrary_lines << line.to_s
+      self
+    end
+
+    # Sends the GNUPLOT data and commands to +io+.
+    def to_gplot(io = io)
+      to_plot(io) { |ds| ds.to_gplot(io) }
+    end
+
+    private
+
+    def to_plot(io)
+      return unless io
+
+      @sets.each { |var, val| io << "set #{var} #{val}\n" }
+      @arbitrary_lines.each { |line| io << line << "\n" }
+
+      unless @data.empty?
+        io << @cmd
+        io << ' '
+        io << @data.map { |e| e.plot_args }.compact.join(', ')
+        io << "\n"
+
+        @data.each { |ds| io << "e\n" if yield ds } if block_given?
+      end
+
+      io
+    end
+
+  end
+
+  class SPlot < Plot
+
+    def initialize(io = nil, cmd = 'splot')
+      super
+    end
+
+    # Sends the GNUPLOT data and commands to +io+.
+    def to_gplot(io = io)
+      to_plot(io) { |ds| ds.to_gsplot(io) }
+    end
+
+  end
+
+  # Container for a single data set being displayed by GNUPLOT. Each object
+  # has a reference to the actual data being plotted as well as settings that
+  # control the +plot+ command. The data object must support the +to_gplot+
+  # command.
+  #
+  # The other attributes correspond to their related string in the GNUPLOT
+  # command. See the {GNUPLOT documentation}[http://gnuplot.sourceforge.net/documentation.html]
+  # for more information on this.
+
+  class DataSet
+
+    attr_accessor :data, :title, :with, :using, :linewidth, :matrix, :smooth, :axes
+
+    def initialize(data = nil)
+      @data = data
+      yield self if block_given?
+    end
+
+    # Set no title.
+    def notitle
+      @title = 'notitle'
+    end
+
+    # Write the plot arguments to +io+.
+    def plot_args(io = '')
+      # Order of these is important or GNUPLOT barfs on 'em
+      %w[data using axes title matrix smooth with linewidth].each { |arg|
+        plot_arg(io, arg)
+      }
+
+      io
+    end
+
+    # Write the plot data to +io+.
+    def to_gplot(io = '')
+      @data.to_gplot(io) if plot?
+    end
+
+    # Write the splot data to +io+.
+    def to_gsplot(io = '')
+      @data.to_gsplot(io) if plot?
+    end
+
+    private
+
+    def plot_arg(io, arg)
+      var = "@#{arg}"
+      val = instance_variable_get(var) if instance_variable_defined?(var)
+
+      case arg
+        when 'data'
+          io << (val.is_a?(String) ? val : "'-'")
+        when 'title'
+          io << (val =~ /notitle/ ? ' notitle' : " title '#{val}'") if val
+        when 'matrix'
+          io << ' matrix' if val
+        else
+          io << " #{arg} #{val}" if val
+      end
+    end
+
+    def plot?
+      @data && !@data.is_a?(String)
+    end
+
+  end
+
+end
+
+class Array
+
+  # Write GNUPLOT plot data to +io+.
+  def to_gplot(io = '')
+    case x = self[0]
+      when Array
+        x.zip(*self[1..-1]).each { |a| io << a.join(' ') << "\n" }
+        io << 'e'
+      when Numeric then each { |i| io << "#{i}\n" }
+      else x.zip(*self[1..-1]).to_gplot(io)
+    end
+
+    io
+  end
+
+  # Write GNUPLOT splot data to +io+.
+  def to_gsplot(io = '')
+    case x = self[0]
+      when Array
+        y, d = values_at(1, 2)
+
+        x.each_with_index { |xv, i|
+          y.each_with_index { |yv, j|
+            io << [xv, yv, d[i][j]].join(' ') << "\n"
+          }
+        }
+
+        io
+      when Numeric then each { |i| io << "#{i}\n" }
+      else x.zip(*self[1..-1]).to_gsplot(io)
+    end
+
+    io
+  end
+
+end
+
+class Matrix
+
+  # Write GNUPLOT plot data to +io+.
+  def to_gplot(io = '', xgrid = nil, ygrid = nil)
+    xgrid ||= (0...column_size).to_a
+    ygrid ||= (0...row_size).to_a
+
+    ygrid.each_with_index { |y, j|
+      xgrid.each_with_index { |x, i|
+        z = self[j, i]
+        io << "#{x} #{y} #{z}\n" if z
+      }
+    }
+
+    io
+  end
+
+end

data/test/test_gnuplot.rb

@@ -0,0 +1,110 @@
+require '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.map { |v| 3 * v }
+    d3 = d2.map { |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 { |ds|
+      ds.with  = 'lines'
+      ds.using = '1:2'
+      ds.data  = [[0, 1, 2], [1, 2, 5]]
+    }
+
+    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 { |p|
+      p.set 'output', "'foo'"
+      p.set 'terminal', 'postscript enhanced'
+    }
+
+    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 { |gp| gp.set 'title', 'foo' }
+    assert "'foo'", plot['title']
+
+    plot.set 'title', "'bar'"
+    assert "'bar'", 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 < Test::Unit::TestCase
+
+  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

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: blackwinter-gnuplot
+version: !ruby/object:Gem::Version 
+  hash: 97
+  prerelease: 
+  segments: 
+  - 2
+  - 3
+  - 5
+  - 1
+  version: 2.3.5.1
+platform: ruby
+authors: 
+- Roger Pack
+- Jens Wille
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-22 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-nuggets
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- rogerpack2005@gmail.com
+- jens.wille@uni-koeln.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- ChangeLog
+- LICENSE.txt
+- README.rdoc
+files: 
+- AUTHORS.txt
+- ChangeLog
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- examples/.gitignore
+- examples/discrete_points.rb
+- examples/histogram.rb
+- examples/multiple_data_sets.rb
+- examples/output_file1.rb
+- examples/output_file2.rb
+- examples/sine_wave.rb
+- lib/gnuplot.rb
+- lib/gnuplot/version.rb
+- test/test_gnuplot.rb
+has_rdoc: true
+homepage: http://github.com/blackwinter/ruby_gnuplot
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Utility library to aid in interacting with GNUPLOT
+test_files: 
+- examples/discrete_points.rb
+- examples/histogram.rb
+- examples/multiple_data_sets.rb
+- examples/output_file1.rb
+- examples/output_file2.rb
+- examples/sine_wave.rb
+- test/test_gnuplot.rb