numplot 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d354b2cc2c06f15dfb5130ea2ee5c48f1f157f2
+  data.tar.gz: 04ddb3b2c06dc8f02b43d9920b019df571abc151
+SHA512:
+  metadata.gz: 7aad96c6901b48822dcc03bc3ae5dd6bc2f0c90e5662c3dab090295d553096e9a08321e56b050bbdac9586f0265646a66ee885b6a5045c033bb213e1d768a444
+  data.tar.gz: e9acde2f4a6165047da57a44de4f223a751a89c084d284fe7508f2467fffcf81ee598d64897f812517483a95c749976b94fa0decbd22813d3f3597b81156867d

data/lib/numplot/option.rb

@@ -0,0 +1,83 @@
+
+module NumPlot
+  # The class handling options on gnuplot command.
+  # @!visibility private
+  class Option
+    def initialize(name, converter, aliases)
+      @name = name
+      @converter = converter
+      @aliases = aliases
+    end
+    
+    def plot_arg(h)
+      ([@name] + @aliases).each do |key|
+        if h.has_key? (key)
+          return " #{@name} #{@converter[h[key]]}"
+        end
+      end
+      
+      ""
+    end
+    
+    def self.[](name, *aliases)
+      new(name, proc{|x| x }, aliases)
+    end
+  end
+
+  # The class handling color options on gnuplot command.
+  # @!visibility private
+  class ColorOption < Option
+    def self.[](name, *aliases)
+      new(name, Conversion.method(:convert_color), aliases)
+    end
+  end
+
+  # The class handling font options on gnuplot command.
+  # @!visibility private
+  class FontOption < Option
+    def self.[](name, *aliases)
+      new(name, Conversion.method(:convert_font), aliases)
+    end
+  end
+
+  # The class handling on/off options on gnuplot command.
+  # @!visibility private
+  class BoolOption
+    def initialize(name, *aliases)
+      @name = name; @aliases = aliases
+    end
+    
+    def plot_arg(h)
+      ([@name] + @aliases).each do |key|
+        return " #{@name}" if h.has_key?(key)
+      end
+      
+      ""
+    end
+    
+    class << self
+      alias [] new
+    end
+  end
+
+  # The class handling XXX/noXXX options on gnuplot command
+  # @!visibility private
+  class YesNoOption
+    def initialize(name)
+      @name = name
+      @no_name = "no#{name}".intern
+    end
+
+    def plot_arg(h)
+      return " #{@name}" if h.has_key?(@name) && h[@name]
+      return " #{@name}" if h.has_key?(@no_name) && !h[@no_name]
+      return " #{@no_name}" if h.has_key?(@no_name) && h[@no_name]
+      return " #{@no_name}" if h.has_key?(@name) && !h[@name]
+      ""
+    end
+
+    class << self
+      alias [] new
+    end
+  end
+end

data/lib/numplot.rb

@@ -0,0 +1,667 @@
+require 'numplot/option'
+
+require 'set'
+
+# Call the given block once.
+# This method is used to make yard to ignore the code in a block.
+def __yard_ignore_here; yield; end
+
+# A module wrapping gnuplot {http://www.gnuplot.info/}.
+module NumPlot
+  # The collection of methods converting ruby objects to gnuplot strings.
+  #
+  # @!visibility private
+  module Conversion
+    module_function
+    
+    def convert_range(range)
+      case range
+      when String then range
+      when Range then "[#{range.begin}:#{range.end}]"
+      when Array
+        if range.size != 2
+          raise TypeError, "Cannot convert #{range.inspect} to gnuplot's range"
+        end
+        "[#{range[0]}:#{range[1]}]"
+      else
+        raise TypeError, "Cannot convert #{range.inspect} to gnuplot's range"
+      end
+    end
+
+    def convert_color(color)
+      case color
+      when RGB then color.to_gnuplot_string
+      when String, Integer then color
+      else
+        raise TypeError, "Cannot convert #{color.inspect} to gnuplot's color"
+      end
+    end
+
+    def convert_font(font)
+      case font
+      when String then font
+      when Font then font.to_gnuplot_string
+      else
+        raise TypeError, "Cannot convert #{font.inspect} to gnuplot's font"
+      end
+    end
+    
+    def quote(str)
+      "\"#{str}\""
+    end
+  end
+
+  # The class representing colors in gnuplot.
+  #
+  # You can use three types of color specifications like the following
+  # examples.
+  #
+  # Example:
+  #   RGB[255, 0, 0] # => Red
+  #   RGB["#00ff00"] # => Green
+  #   RGB["blue"]    # => blue
+  #
+  class RGB
+    # Create a new instance of RGB class.
+    #
+    # You can give three styles of arguments to specify a color.
+    # * an RGB component as three integers like NumPlot::RGB.new(0, 255, 0)
+    # * a "#xxyyzz" style string like NumPlot::RGB.new("#ff007f")
+    # * a string of the name of a color like NumPlot::RGB.new("blue")
+    def initialize(*args)
+      if args.size == 1 && String === args[0]
+        @s = args[0]
+      elsif args.size == 3
+        @s = "#%02x%02x%02x" % args
+      else
+        raise TypeError, "Unknown color format: #{args.inspect}"
+      end
+    end
+    
+    # Convert self to gnuplot "rgbcolor" string.
+    # @visibility private
+    def to_gnuplot_string
+      "rgbcolor \"#{@s}\""
+    end
+
+    class << self
+      # @method [](*args) 
+      #   Create a new RGB object. See {#initialize}.
+      #   @return [RGB] A new RGB object
+      __yard_ignore_here{ alias [] new }
+    end
+  end
+
+  # The class representing a font in gnuplot.
+  #
+  # Example:
+  #   Font["ariel"] # ariel font, default size
+  #   Font["ariel", 12] # ariel font, the size is 12 point
+  class Font
+    # Create a new Font object.
+    # @param fontname[String] the name of font
+    # @param size[String, nil] the size of font, nil to default
+    # @example
+    #   Font.new("ariel") # ariel font, default size
+    #   Font.new("ariel", 12) # ariel font, the size is 12 point
+    def initialize(fontname, size=nil)
+      @s = size ? "#{fontname},#{size}" : fontname
+    end
+
+    # Convert self to gnuplot font (quoted) string.
+    # @visibility private
+    def to_gnuplot_string
+      "\"#{@s}\""
+    end
+
+    class << self
+      # @!method [](fontname, size=nil) 
+      #   Create a new Font object. See {#initialize}.
+      #   @return [Font] A new Font object
+      __yard_ignore_here{ alias [] new }
+    end    
+  end
+
+  # The class communicating a gnuplot subprocess.
+  #
+  # In many cases, you use {Plotter#plot} and you don't need to use
+  # this class directly.
+  class Process
+    # Create a Process object for already opened pipe.
+    # Normally, you had better to use {.open} to create a new object.
+    # @param pipe a pipe to communicate to a subprocess
+    # @param wait wait for the output from a subprocess 
+    def initialize(pipe, wait)
+      @pipe = pipe
+      @wait = wait
+      @output = nil
+    end
+
+    # Output string from a gnuplot subprocess.
+    # @return [String, nil]
+    attr_reader :output
+
+    # Close the pipe and terminate the subprocess.
+    #
+    # If you specify wait=true when the object is constructed,
+    # @return [void]
+    def close
+      if @wait
+        @pipe.close_write
+        @output = @pipe.read
+        @pipe.close
+      else
+        @pipe.close
+      end
+    end
+
+    # Write +str+ to the subprocess.
+    # @return [void]
+    def write(str)
+      @pipe.write(str)
+    end
+
+    # Write +str+ and a newline to the subprocess
+    # @return [void]
+    def puts(str)
+      @pipe.puts(str)
+    end
+
+    # Open a gnuplot process.
+    #
+    # If a block is given, the block is invoked with the opened
+    # Process object. Otherwise, opened Process object is returned.
+    # If you give true as +persist+, -persist option is added to the
+    # command line of gnuplot. 
+    # @param persist add -persist option to gnuplot as a command line option
+    # @param waiting wait for termination of stdout of gnuplot pipe
+    # @param name the name of the gnuplot executable file
+    def self.open(persist=true, waiting=true, name="gnuplot")
+      pr = new(IO.popen(command(name, persist), "w+"), waiting)
+      
+      if block_given?
+        begin
+          yield pr
+        ensure
+          pr.close
+        end
+        return pr.output
+      else
+        return pr
+      end
+    end
+
+    # Return a command line string to invoke a subprocess.
+    # @!visibility private
+    def self.command(name, persist)
+      name += " -persist" if persist
+      name
+    end
+  end
+
+  # The plotter class.
+  # To plot something, you need to create a Plotter object,
+  # set parameters to the object, add data sets to the object,
+  # and call {#plot} as in the example below.
+  # @example
+  #   # An array of data to plot
+  #   data =  -2.0.step(2.0, 0.05).map{|x| [x, Math.sin(x)]}
+  #   # Create a new Plotter object
+  #   plotter = NumPlot::Plotter.new
+  #   # Set parameters
+  #   plotter.set("term", "png")
+  #   plotter.set("output", "\"sin.png\"") # Need to quote 
+  #   plotter.xrange -2.0 .. 2.0
+  #   # Set datasets
+  #   plotter.datasets << NumPlot::Dataset.rows(data, title: "sin(x)", with: line)
+  #   # Plot (output to sin.png)
+  #   plotter.plot
+  class Plotter
+    include Conversion
+
+    # Create a new Plotter object.
+    # You can specifiy the plot command (plot/splot)
+    # by plot_command parameter.
+    # @param plot_command[String] "plot" or "splot"
+    def initialize(plot_command = "plot")
+      @plot_command = plot_command
+      @commands = []
+      @datasets = []
+    end
+
+    # An array of all data sets.
+    # @deprecated
+    # @return [Array] 
+    attr_reader :datasets
+
+    # Add a command string to the list of commands.
+    # The commands are executed when {#plot} is called.
+    # @param command[String] a command to add
+    # @return [self]
+    def add_command(command)
+      @commands << command
+      self
+    end
+    private :add_command
+    
+    # Gnuplot "set" command.
+    # This method is generic, but 
+    # you can use some useful methods like {#xrange} and {#xlabel} for
+    # "set" command.
+    # @param key[String]
+    #   the first argument for gnuplot "set" command like "term", "output".
+    # @param values[Array<String>] the rest arguments for gnuplot "set" command
+    # @return [self]
+    def set(key, *values)
+      add_command("set #{key} #{values.join(' ')}")
+    end
+
+    # Gnuplot "unset" command.
+    # @param key[String]
+    #   the first argument for gnuplot "unset" command
+    # @param values[Array<String>] the rest arguments for gnuplot "unset" command
+    # @see #set
+    # @return [self]
+    def unset(key, *values)
+      add_command("unset #{key} #{values.join(' ')}")
+    end
+
+    # Add a dataset to the plotter.
+    # @param dataset[Dataset] a dataset
+    # @return [self]
+    def add_dataset(dataset)
+      @datasets << dataset
+      self
+    end
+
+    alias << add_dataset
+
+    # @!macro [new] range
+    #   @overload $0(range, *opts)
+    #     Set $0 parameter.
+    #     You can specify the range with one of three styles.
+    #     * a string such as: "[-1.0:1.0]" or "[:2.0]"
+    #     * a range such as: -1.0 .. 1.0 or -Float::INFINITY .. 2.0
+    #     * an array such as: [-1.0, 1.0] or [nil, 2.0]
+    #     You can also specify the following options as args:
+    #     * "reverse"
+    #     * "no reverse"
+    #     * "writeback"
+    #     * "no writeback"
+    #     @param range[String,Range,Array] the range of x axis
+    #     @param opts[Array<String>] options
+    #     @return [self]
+
+    # @macro range
+    def xrange(*args); _range("xrange", *args); end
+    # @macro range
+    def yrange(*args); _range("yrange", *args); end
+    # @macro range
+    def zrange(*args); _range("zrange", *args); end
+    # @macro range
+    def x2range(*args); _range("x2range", *args); end
+    # @macro range
+    def y2range(*args); _range("y2range", *args); end
+    
+    def _range(type, r, opts={})
+      gnuplot_options = ""
+      RANGE_OPTIONS.each do |opt|
+        gnuplot_options << opt.plot_arg(opts)
+      end
+      
+      set(type, convert_range(r), gnuplot_options)
+    end
+    private :_range
+
+    # @!visibility private
+    RANGE_OPTIONS = [YesNoOption[:reverse], YesNoOption[:writeback]]
+
+    # @!macro [new] label
+    #   @overload $0(label, opts={})
+    #     Set $0 parameter.
+    #     You can specify the following options as a hash:
+    #     * offset: OFFSET
+    #     * font: FONT
+    #     * textcolor: COLOR (tc: is also available)
+    #     * enhanced: true OR noenhanced: true
+    #     * rotate: (TODO: FIX IT) OR  norotate: true
+    #     @param label[String] label string
+    #     @param opts[{Symbol => Object}] options
+    #     @return [self]
+
+    # @macro label
+    def xlabel(*args); _label("xlabel", *args); end
+    # @macro label
+    def ylabel(*args); _label("ylabel", *args); end
+    # @macro label
+    def zlabel(*args); _label("zlabel", *args); end
+    # @macro label
+    def x2label(*args); _label("x2label", *args); end
+    # @macro label
+    def y2label(*args); _label("y2label", *args); end
+    
+    def _label(type, *args)
+      set(type, LabelParser.parse(*args))
+    end
+    private :_label
+
+    # Plot given datasets with given parameters.
+    # @overload plot(opts={})
+    #   Open a gnuplot process and write commands and data to the process.
+    #   You get the result of plotting on a window or an image file
+    #   
+    #   You can specify the following options:
+    #   * :persist - Add -persist to gnuplot command.
+    #     The default value is true.
+    #   * :waiting - Wait a gnuplot process to be terminate.
+    #     The default value is true. If this value is true and
+    #     the diagram is drawed on a new window, the ruby program
+    #     is stopped until the window is closed. On the other hand,
+    #     if this value is false, the ruby program continue
+    #     although the window remains opened.
+    #   * :gnuplot_command - gnuplot command name.
+    # 
+    #   @param opts options
+    #   @return [void]
+    # 
+    # @overload plot(io)
+    #   Output all commands and data to IO object.
+    # 
+    #   Normally, you specify {Process} object as io.
+    #   For debug use, you can specify the StringIO object as io.
+    # 
+    #   @param io[#write, #puts] output target
+    #   @return [void]
+    def plot(arg={})
+      
+      if Hash === arg
+        Process.open(arg.fetch(:persist, true),
+                     arg.fetch(:waiting, true),
+                     arg.fetch(:gnuplot_command, "gnuplot")) do |pr|
+          plot_to_io(pr)
+        end
+      else
+        plot_to_io(arg)
+      end
+    end
+
+    # Output all commands and data to IO object.
+    def plot_to_io(pr)
+      @commands.each{|cmd| pr.puts(cmd) }
+      pr.write(@plot_command)
+      pr.write(" ")
+      pr.write(@datasets.map{|e| e.to_plot_arg }.join(", "))
+      pr.write("\n")
+      pr.write(@datasets.map{|e| e.to_plot_dataset }.compact.join("e\n"))
+    end
+    private :plot_to_io
+  end
+
+  # The dataset class plotted by {Plotter}.
+  # 
+  # You can construct a dataset object using one of the following three methods:
+  # * {.columns}: construct a dataset from columns
+  # * {.rows}: construct a dataset from rows
+  # * {.histogram}: construct a histogram dataset
+  # 
+  # You need to choose from {.columns} and {.rows} according to
+  # the arrangement of your data.
+  #
+  # The dataset object is registered to {Plotter} object using
+  # {Plotter#add_dataset}.
+  # 
+  # == Parameters for a dataset
+  # When you call {.columns}, {.rows}, or {.histogram},
+  # you can give some parameters to determine the style of 
+  # plotting.
+  # The parameters are as follows. If you know the details
+  # of these parameters, please read the gnuplot documents.
+  # * title: "TITLE" or notitle: true
+  # * with: "points", "dots", etc.
+  # * axis:
+  # * linestyle: a style number (ls: is also available)
+  # * linetype: a line type number 
+  # * linewidth: a line width multiplier (default is 1.0),
+  #   (lw: is also available)
+  # * linecolor: a color number or an {RGB} object.
+  #   (lc: is also available)
+  # * pointtype: a point type number (pt: is also available)
+  # * pointsize: a point size multiplier (default is 1.0),
+  #   (ls: is also available)
+  # * fill: a fill style (fs: is also available)
+  # * nohidden3d: true if you need to activate this option
+  # * nocontours: true if you need to activate this option
+  # * nosurface: true if you need to activate this option
+  class Dataset
+    def initialize(data, opts={})
+      @data = data
+      @opts = opts
+    end
+
+    # Construct a dataset object form columns.
+    #
+    # If your data are xs = [x0, x1, x2, ... ] and ys = [y0, y1, y2, ...],
+    # you should use this method as:
+    #   Dataset.columns([xs, ys])
+    # 
+    # If your data is transposed, you need to use {.columns} instead of
+    # this method.
+    #
+    # You can give some parameters as a hash
+    # to set a plotting style. Please see
+    # {Dataset}.
+    # @param data[Enumerable<Enumerable<Numeric>>] 
+    # @param opts[{Symbol => object}] options
+    # @return [Dataset]
+    def self.columns(data, opts={})
+      new(data.map(&:to_a).transpose, opts)
+    end
+
+    # Construct a dataset object form rows.
+    #
+    # If your data is [[x0, y0], [x1, y1], ...],
+    # you should use this method as:
+    #   Dataset.rows(data)
+    # 
+    # If your data is transposed, you need to use {.rows} instead of
+    # this method.
+    #
+    # You can give some parameters as a hash
+    # to set a plotting style. Please see
+    # {Dataset} for details.
+    # @param data[Enumerable<Enumerable<Numeric>>] 
+    # @param opts[{Symbol => object}] options
+    # @return [Dataset]
+    def self.rows(data, opts={})
+      new(data.map(&:to_a), opts)
+    end
+
+
+    # Construct a histogram dataset object.
+    #
+    # You need to give some parameters to construct a histogram.
+    # * dim: the dimension of your data, now only 1-dim data is supported
+    #   (default is 1)
+    # * binsize: the bin size (required, Numeric)
+    # * base: the coordinate of a left side of a bin (default is 0.0).
+    #   If binsize = 1.0 and base = 0.0, the bins are
+    #   ..., [-1.0, 0.0), [0.0, 1.0), ... .
+    #   If binsize = 1.0 and base = 0.5, the bins are
+    #   ..., [-1.5, -0.5), [-0.5, 0.5), [0.5, 1.5), ... .
+    # * histogram_style: You can choose one of the following normalization
+    #   scheme:
+    #   * :count  not normalized
+    #   * :ratio  normailized to the number of data points
+    #   * :density normalized to (the number of data points)*(binsize).
+    #     You choose this option if you want to show the probability density
+    #     function from the data.
+    # * cumulative: construct a cumulative histogram if true.
+    #   If the cumulative option is true, the meaning of
+    #   histogram_style option is changed.
+    #   * :count not normalized
+    #   * :ratio, :density normalized by the number of data, this means that
+    #     the maximum value of a cumulative histogram is normalized to 1.
+    # 
+    # You can also give some other parameters to determine
+    # a plotting style. See {Dataset} for details.
+    #
+    # @example
+    #   require 'randomext' # install randomext gem
+    #   # 1000 random samples from the standard normal distribution.
+    #   rng = Random.new
+    #   data = Array.new(1000){ rng.standard_normal }
+    #   datasets = Dataset.histo(data, binsize: 0.1, histogram_style: :density,
+    #                      title: "Random samples from the normal distribution")
+    #   
+    # @param data[Enumerable<Numeric>] a sequence of numbers
+    # @param opts[{Symbol => Object}] options
+    # @return [Dataset]
+    def self.histogram(data, opts={})
+      case opts.fetch(:dim, 1)
+      when 1
+        histo1d(data, opts)
+      when 2
+        raise NotImplementedError, "Histogram for 2D data is not implemented yet"
+      else
+        raise ArgumentError, "You can use only 1D or 2D histogram data"
+      end
+    end
+
+    # @!visibility private 
+    def self.histo1d(data, opts)
+      binsize = opts.fetch(:binsize).to_f
+      basepoint = opts.fetch(:base, 0).to_f
+      histo_style = opts.fetch(:histogram_style, :count)
+      cumulative = opts.fetch(:cumulative, false)
+
+      bins = Hash.new(0)
+      data.each {|point| bins[bin1d(point, binsize, basepoint)] += 1 }
+      
+      if cumulative
+        plotdata = cumulative_1d(bins, histo_style, data.size, binsize)
+      else
+        plotdata = histogram_plotdata_1d(bins, histo_style, data.size, binsize)
+      end
+      
+      opts[:with] ||= "boxes"
+      Dataset.rows(plotdata, opts)
+    end
+
+    # @!visibility private
+    def self.bin1d(point, binsize, basepoint)
+      (point + binsize/2).div(binsize) * binsize
+    end
+
+    # @!visibility private
+    def self.histogram_plotdata_1d(bins, style, numdata, binsize)
+      r = case style
+          when :count then 1.0
+          when :ratio then numdata.to_f
+          when :density then numdata*binsize
+          end
+      bins.map{|k, v| [k, v/r, binsize]}
+    end
+
+    # @!visibility private
+    def self.cumulative_1d(bins, style, numdata, binsize)
+      cumulative_data = []
+      bins.sort_by{|k, v| k }.inject(0.0){|sum, (k, v)|
+        cumulative_data << [k, sum+v]
+        sum + v
+      }
+      r = case style
+          when :count then 1.0
+          when :ratio, :density then numdata
+          end
+      cumulative_data.map{|k, v| [k, v/r, binsize] }
+    end
+    
+    private_class_method :bin1d, :histo1d, :histogram_plotdata_1d, :cumulative_1d
+    
+    class << self; alias histo histogram; end
+
+    # Return a stirng for gnuplot's "plot" or "splot" like "'-' with dots"
+    # @return [String] 
+    # @!visibility private
+    def to_plot_arg
+      ret = "'-'"
+      OPTIONS.each do |opt|
+        ret << opt.plot_arg(@opts)
+      end
+
+      ret
+    end
+
+    # Return a string for gnuplot's data like "1 2 3\n4 4 6\ne"
+    # @!visibility private
+    def to_plot_dataset
+      @data.map{|dataline| dataline.join(" ")}.join("\n") + "\ne"
+    end
+
+    # @!visibility private
+    class Title
+      def plot_arg(h)
+        if h[:notitle]
+          " notitle"
+        elsif h.has_key?(:title)
+          " title \'#{h[:title]}\'"
+        else
+          ""
+        end
+      end
+    end
+
+    # @!visibility private
+    OPTIONS = [Title.new,
+               Option[:axis],
+               Option[:with],
+               Option[:linestyle, :ls],
+               Option[:linetype, :lt],
+               Option[:linewidth, :lw],
+               ColorOption[:linecolor, :lc],
+               Option[:pointtype, :pt],
+               Option[:pointsize, :ps],
+               Option[:fill, :fs],
+               BoolOption[:nohidden3d],
+               BoolOption[:nocontours],
+               BoolOption[:nosurface],
+               Option[:palette],
+              ]
+
+
+  end
+
+  # @!visibility private
+  class LabelParser
+    def self.parse(*args)
+      if Hash === args.last
+        opts = args.pop
+      else
+        opts = {}
+      end
+
+      label = args.shift
+      
+      raise ArgumentError, "Unknown label argument #{args.inspect}" if !args.empty?
+      raise ArgumentError, "No label text" if label.nil?
+      
+      gnuplot_string = Conversion.quote(label)
+      
+      OPTIONS.each do |opt|
+        gnuplot_string << opt.plot_arg(opts)
+      end
+
+      gnuplot_string
+    end
+
+    OPTIONS = [Option[:offset],
+               FontOption[:font],
+               ColorOption[:textcolor, :tc],
+               YesNoOption[:enhanced],
+               Option[:rotate],
+               BoolOption[:norotate],
+              ]
+  end
+  
+
+end

data/sample/sample1.rb

@@ -0,0 +1,34 @@
+require 'numplot'
+
+# Draw a random sample from the normal distribution (sigma = 0.3)
+# with Box-Muller's method. 
+def rand_normal
+  x = rand
+  y = rand
+  Math.sqrt(-2*Math.log(x))*Math.cos(2*Math::PI*y)*0.3
+end
+
+plotter = NumPlot::Plotter.new
+
+x_sin_pi_x = (-1.0 .. 1.0).step(0.05).map{|x| [x, Math.sin(Math::PI*x)] }
+plotter <<
+  NumPlot::Dataset.rows(x_sin_pi_x, with: "points", title: "sin(x)")
+
+xs = (0.0 .. 1.0).step(0.05)
+squares = xs.map{|x| x**2 }
+plotter <<
+  NumPlot::Dataset.columns([xs, squares], with: "lines", title: "x^2")
+
+normal_random_dist = Array.new(10000){ rand_normal }
+plotter <<
+  NumPlot::Dataset.histo(normal_random_dist,
+                         binsize: 0.1, histogram_style: :density,
+                         title: "a normal distribution")
+
+plotter.xrange(-1.0 .. 1.0)
+plotter.xlabel("x", font: NumPlot::Font["ariel", 12])
+plotter.ylabel("y", font: NumPlot::Font["ariel"])
+
+plotter.set("key", "below")
+
+plotter.plot

data/test/run_test.rb

@@ -0,0 +1,5 @@
+testdir = File.dirname(__FILE__)
+Dir.glob("#{testdir}/**/test_*.rb") do |dir|
+  load dir
+end
+

data/test/test_labelparser.rb

@@ -0,0 +1,14 @@
+require 'numplot'
+
+require 'test-unit'
+
+class TestRGB < Test::Unit::TestCase
+  include NumPlot
+  
+  def test_s_parse
+    assert_equal("\"foo\"", LabelParser.parse("foo"))
+    assert_equal("\"foo\" offset 32 font \"bar,14\"",
+                 LabelParser.parse("foo", offset: 32, font: Font["bar",14]))
+                  
+  end
+end

data/test/test_options.rb

@@ -0,0 +1,20 @@
+require 'numplot'
+
+require 'test-unit'
+
+class TestYesNoOption < Test::Unit::TestCase
+  include NumPlot
+  
+  def test_plot_arg
+    assert_equal("", YesNoOption[:foo].plot_arg({}))
+    assert_equal("", YesNoOption[:foo].plot_arg({bar:true}))
+    assert_equal(" foo",
+                 YesNoOption[:foo].plot_arg({bar:true, foo:true}))
+    assert_equal(" nofoo",
+                 YesNoOption[:foo].plot_arg({bar:true, foo:false}))
+    assert_equal(" nofoo",
+                 YesNoOption[:foo].plot_arg({bar:true, nofoo:true}))
+    assert_equal(" foo",
+                 YesNoOption[:foo].plot_arg({bar:true, nofoo:false}))
+  end
+end

data/test/test_plotter.rb

@@ -0,0 +1,14 @@
+require 'numplot'
+
+require 'test-unit'
+require 'stringio'
+
+class TestRGB < Test::Unit::TestCase
+  include NumPlot
+  
+  def test_xrange
+    strio = StringIO.new
+    Plotter.new.xrange(1 .. 2, noreverse: false, nowriteback: true).plot(strio)
+    assert_equal("set xrange [1:2]  reverse nowriteback\nplot \n", strio.string)
+  end
+end

data/test/test_rgb.rb

@@ -0,0 +1,13 @@
+require 'numplot'
+
+require 'test-unit'
+
+class TestRGB < Test::Unit::TestCase
+  include NumPlot
+  
+  def test_to_gnuplot_string
+    assert_equal("rgbcolor \"black\"", RGB["black"].to_gnuplot_string)
+    assert_equal("rgbcolor \"#0f12af\"", RGB["#0f12af"].to_gnuplot_string)
+    assert_equal("rgbcolor \"#0f12af\"", RGB[0xf, 0x12, 0xaf].to_gnuplot_string)
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: numplot
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Ippei Obayashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  This library is an wrapper for gnuplot.
+email: ohai@kmc.gr.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/numplot.rb
+- lib/numplot/option.rb
+- sample/sample1.rb
+- test/run_test.rb
+- test/test_labelparser.rb
+- test/test_options.rb
+- test/test_plotter.rb
+- test/test_rgb.rb
+homepage: http://www.kmc.gr.jp
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: An wrapper for gnuplot
+test_files: []
+has_rdoc: