numo-gnuplot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a5482f076a126f3270d221c2ad38455ac266b6a
+  data.tar.gz: 1115269a4c0e558c2272f14b36e591e41d26bd28
+SHA512:
+  metadata.gz: 0cb38d93f404dca82818117ae8f7620c160bbd3eb3e6f3abfcf3a2d9cd44b05d2d3a445b6f2592b6011446fd7038a0da6f4660131a659c1cefb976484e0f5161
+  data.tar.gz: 76b7602cd0fe6f0e23e5a62dddc01ff63cf5064ad54a5bf8a3d8594dfcec9d600990a81dc539c72cfc490ad0b3913220f1214ca70b94f734a4e1286b3c7a0742

data/.gitignore

@@ -0,0 +1,54 @@
+*.gem
+*.rbc
+Gemfile.lock
+InstalledFiles
+SetupConfig
+SetupReceipt
+coverage
+pkg/
+spec/reports
+spec/examples.txt
+spec/*/*.dat
+spec/*/*.csv
+test/tmp
+test/version_tmp
+tmp/
+.config
+*~
+*/*~
+*/*/*~
+*.bak
+*/*.bak
+*/*/*.bak
+.#*
+*/.#*
+*/*/.#*
+rhosts
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+.yardoc/
+_yardoc/
+doc/
+rdoc/
+
+## Environment normalization:
+.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# examples
+/examples/*.png

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in numo-gnuplot.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Masahiro TANAKA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# Numo::Gnuplot : Gnuplot interface for Ruby
+
+* Alpha version under development.
+* [GitHub site](https://github.com/masa16/numo-gnuplot)
+
+Although there are many [other Gnuplot interface libraries for Ruby](https://github.com/masa16/numo-gnuplot#related-work),
+none of them have so simple interface as to obtain an XY data plot by just typing:
+
+    plot x,y
+
+Numo::Gnuplot achieves this by providing only one class which has
+the same inteface as Gnuplot command line, and no other class which
+causes extra learning costs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'numo-gnuplot'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install numo-gnuplot
+
+## Usage
+
+* All examples require to load Numo::Gnuplot class:
+
+```ruby
+require "numo/gnuplot"
+```
+
+* The first example showing how it works.
+
+```ruby
+gp = Numo::Gnuplot.new
+gp.set title:"First Example"
+gp.plot "sin(x)"
+```
+
+* You can avoid receiver.
+
+```ruby
+Numo::Gnuplot.new.instance_eval do
+  set title:"Second Example"
+  plot "sin(x)"
+end
+```
+
+* The same thing in short.
+
+```ruby
+Numo.gnuplot do
+  set title:"Third Example"
+  plot "sin(x)"
+end
+```
+
+* Interactive plotting with IRB:
+
+```
+$ irb -r numo/gnuplot
+irb(main):001:0> pushb Numo.gnuplot
+irb(gnuplot):002:0> set t:"Forth Example"
+irb(gnuplot):003:0> plot "sin(x)"
+```
+
+* Plotting X-Y data.
+
+```ruby
+require "numo/gnuplot"
+
+x = (0..100).map{|i| i*0.1}
+y = x.map{|i| Math.sin(i)}
+
+Numo.gnuplot do
+  set title:"X-Y data plot"
+  plot x,y, w:'lines', t:'sin(x)'
+end
+```
+
+* Plotting X-Y data in NArray.
+
+```ruby
+require "numo/gnuplot"
+require "numo/narray"
+
+x = Numo::DFloat[0..100]/10
+y = Numo::NMath.sin(x)
+
+Numo.gnuplot do
+  set title:"X-Y data plot in Numo::NArray"
+  plot x,y, w:'lines', t:'sin(x)'
+end
+```
+
+* Multiple data are separated by Hash or put into Array.
+
+```ruby
+require 'numo/gnuplot'
+require 'numo/narray'
+NM = Numo::NMath
+
+n = 60
+x = Numo::DFloat[-n..n]/n*10
+
+Numo.gnuplot do
+  set title:"multiple data series"
+  # separate by Hash
+  plot x,NM.sin(x), {w:'points',t:'sin(x)'}, x,x*NM.sin(x),{w:"lines",t:'x*sin(x)'}
+  # or separate into Array
+  # plot [x,NM.sin(x), w:'points',t:'sin(x)'], [x,x*NM.sin(x),w:"lines",t:'x*sin(x)']
+  # (here last item in each Array should be Hash in order to distinguish from array data)
+  gets
+end
+```
+
+* Plotting 2D arrays in 3D.
+
+```ruby
+require 'numo/gnuplot'
+require 'numo/narray'
+
+n = 60
+x = (Numo::DFloat.new(1,n).seq/n-0.5)*30
+y = (Numo::DFloat.new(n,1).seq/n-0.5)*30
+r = Numo::NMath.sqrt(x**2+y**2) + 1e-10
+z = Numo::NMath.sin(r)/r
+
+Numo.gnuplot do
+  set title:'2D data plot'
+  set dgrid3d:[60,60]
+  splot z, w:'pm3d', t:'sin(r)/r'
+end
+```
+
+## Related Work
+
+* [Ruby Gnuplot](https://github.com/rdp/ruby_gnuplot/tree/master)
+* [GNUPlotr](https://github.com/pbosetti/gnuplotr)
+* [GnuPlotter](https://github.com/maasha/gnuplotter)
+* [GnuplotRB](https://github.com/dilcom/gnuplotrb)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/[USERNAME]/numo-gnuplot.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/examples/all.rb

@@ -0,0 +1,20 @@
+require "numo/gnuplot"
+
+gp = Numo.gnuplot
+
+puts "mouse/key on window to continue"
+Dir.glob("ex*.rb") do |frb|
+  gp.reset
+  load frb
+  gp.pause mouse:"any"
+end
+
+gp.set term:"png"
+
+Dir.glob("ex*.rb") do |frb|
+  fimg = File.basename(frb,".rb")+".png"
+  gp.reset
+  gp.set output:fimg
+  load frb
+  puts "wrote #{fimg}"
+end

data/examples/ex001.rb

@@ -0,0 +1,7 @@
+Numo.gnuplot do
+  set xrange:-5..10
+  set title:'Math function example'
+  set xlabel:'x'
+  set ylabel:'y'
+  plot 'x*sin(x)', with:'lines', lt:{rgb:'blue',lw:3}
+end

data/examples/ex002.rb

@@ -0,0 +1,11 @@
+# X-Y data plot
+
+x = 20.times.map{|i| i*0.5}
+y = x.map{|i| i*Math.sin(i)}
+
+Numo.gnuplot do
+  set title:'X-Y data plot example'
+  set xlabel:'x'
+  set ylabel:'y'
+  plot x,y, with:'lp', lt:{rgb:'blue',lw:3}
+end

data/examples/ex003.rb

@@ -0,0 +1,10 @@
+require 'numo/narray'
+
+# X-Y data plot with Numo::NArray
+x = Numo::DFloat[0..100]/10
+y = Numo::NMath.sin(x)
+
+Numo.gnuplot do
+  set title:"X-Y data plot with Numo::NArray"
+  plot x,y, w:'lines', t:'sin(x)'
+end

data/examples/ex004.rb

@@ -0,0 +1,6 @@
+# multiple function plot (Array separated)
+
+Numo.gnuplot do
+  set title:"Multiple function plot"
+  plot ['sin(x)', w:"lp"],['x*sin(x)',w:"lines"]
+end

data/examples/ex005.rb

@@ -0,0 +1,11 @@
+require 'numo/narray'
+
+# multiple data series plot (Hash separated)
+n = 60
+x = Numo::DFloat[-n..n]/n*10
+nm = Numo::NMath
+
+Numo.gnuplot do
+  set title:"multiple data series plot"
+  plot x,nm.sin(x), {w:'points',t:'sin(x)'}, x,x*nm.sin(x),{w:"lines",t:'x*sin(x)'}
+end

data/examples/ex010.rb

@@ -0,0 +1,14 @@
+require "numo/narray"
+
+# 3D plot of 2D data with Numo::NArray
+n = 60
+x = (Numo::DFloat.new(1,n).seq/n-0.5)*30
+y = (Numo::DFloat.new(n,1).seq/n-0.5)*30
+r = Numo::NMath.sqrt(x**2+y**2) + 1e-10
+z = Numo::NMath.sin(r)/r
+
+Numo.gnuplot do
+  set title:'3D plot of 2D data'
+  set dgrid3d:[60,60]
+  splot z, w:'pm3d', t:'sin(r)/r'
+end

data/examples/ex011.rb

@@ -0,0 +1,22 @@
+require "numo/narray"
+
+# 3D plot of XYZ data with Numo::NArray
+df = Numo::DFloat
+nm = Numo::NMath
+n = 120
+x = (df.new(1,n).seq/n-0.5)*30
+y = (df.new(n,1).seq/n-0.5)*30
+r = nm.sqrt(x**2+y**2) + 1e-10
+z = nm.sin(r)/r
+x += df.zeros(n,1)
+y += df.zeros(1,n)
+
+Numo.gnuplot do
+  set title:'3D plot of XYZ data',
+      palette:{rgbformula:[22,13,-31]},
+      dgrid3d:[60,60],
+      xlabel:'x',
+      ylabel:'y',
+      zlabel:'sin(r)/r'
+  splot x,y,z, w:'pm3d', t:'sin(r)/r'
+end

data/lib/numo/gnuplot.rb

@@ -0,0 +1,493 @@
+module Numo
+
+  def gnuplot(&block)
+    if block
+      Gnuplot.default.instance_eval(&block)
+    else
+      Gnuplot.default
+    end
+  end
+  module_function :gnuplot
+
+class Gnuplot
+
+  VERSION = "0.1.0"
+  POOL = []
+  DATA_FORMAT = "%.5g"
+
+  class GnuplotError < StandardError; end
+
+  def self.default
+    POOL[0] ||= self.new
+  end
+
+  def initialize(gnuplot_command="gnuplot")
+    @history = []
+    @iow = IO.popen(gnuplot_command+" 2>&1","w+")
+    @ior = @iow
+    @gnuplot_version = send_cmd("print GPVAL_VERSION")[0].chomp
+    @debug = false
+  end
+
+  attr_reader :history
+  attr_reader :gnuplot_version
+
+  # draw 2D functions and data.
+  def plot(*args)
+    _plot_splot("plot",args)
+    nil
+  end
+
+  # draws 2D projections of 3D surfaces and data.
+  def splot(*args)
+    _plot_splot("splot",args)
+    nil
+  end
+
+  def _plot_splot(cmd,args)
+    contents = parse_plot_args(args)
+    r = contents.shift.map{|x|"[#{x.begin}:#{x.end}] "}.join
+    c = contents.map{|x| x.cmd_str}.join(",")
+    d = contents.map{|x| x.data_str}.join
+    run "#{cmd} #{r}#{c}\n#{d}"
+    nil
+  end
+  private :_plot_splot
+
+  # replot is not recommended, use refresh
+  def replot
+    run "replot\n#{@last_data}"
+    nil
+  end
+
+  # The `set` command is used to set _lots_ of options.
+  def set(*args)
+    _set_unset("set",args)
+    nil
+  end
+
+  # The `unset` command is used to return to their default state.
+  def unset(*args)
+    _set_unset("unset",args)
+    nil
+  end
+
+  def _set_unset(cmd,args)
+    args.each do |a|
+      case a
+      when Hash
+        a.each do |k,v|
+          run "#{cmd} #{KvItem.new(k,v)}"
+        end
+      else
+        run "#{cmd} #{a}"
+      end
+    end
+    nil
+  end
+  private :_set_unset
+
+  # The `help` command displays built-in help.
+  def help(s=nil)
+    puts send_cmd "help #{s}\n\n"
+  end
+
+  # The `show` command shows their settings.
+  def show(x)
+    puts send_cmd "show #{x}"
+  end
+
+  #  The `reset` command causes all graph-related options that can be
+  #  set with the `set` command to take on their default values.
+  def reset(x=nil)
+    run "reset #{x}"
+    nil
+  end
+
+  # The `pause` command used to wait for events on window.
+  # Carriage return entry (-1 is given for argument) and
+  # text display option is disabled.
+  #    pause 10
+  #    pause 'mouse'
+  #    pause mouse:%w[keypress,button1,button2,button3,close,any]
+  def pause(*args)
+    send_cmd("pause #{OptsToS.new(*args)}").join.chomp
+    nil
+  end
+
+  # The `load` command executes each line of the specified input file.
+  def load(filename)
+    send_cmd "load '#{filename}'"
+    nil
+  end
+
+  alias kernel_raise :raise
+
+  # The `raise` command raises plot window(s)
+  def raise_plot(plot_window_nb=nil)
+    send_cmd "raise #{plot_window_nb}"
+    nil
+  end
+  alias raise :raise_plot
+
+  # The `lower` command lowers plot window(s)
+  def lower_plot(plot_window_nb=nil)
+    send_cmd "lower #{plot_window_nb}"
+    nil
+  end
+  alias lower :lower_plot
+
+  # The `clear` command erases the current screen or output device as specified
+  # by `set output`. This usually generates a formfeed on hardcopy devices.
+  def clear
+    send_cmd "clear"
+    nil
+  end
+
+  # The `exit` and `quit` commands will exit `gnuplot`.
+  def exit
+    send_cmd "exit"
+    nil
+  end
+
+  # The `exit` and `quit` commands will exit `gnuplot`.
+  def quit
+    send_cmd "quit"
+    nil
+  end
+
+  # The `refresh` reformats and redraws the current plot using the
+  # data already read in.
+  def refresh
+    send_cmd "reflesh"
+    nil
+  end
+
+  # `var` returns Gnuplot variable (not Gnuplot command)
+  def var(name)
+    res = send_cmd("print #{name}").join("").chomp
+    if /undefined variable:/ =~ res
+      kernel_raise GnuplotError,res.strip
+    end
+    res
+  end
+
+  # turn on debug
+  def debug_on
+    @debug = true
+  end
+
+  # turn off debug
+  def debug_off
+    @debug = false
+  end
+
+  #other_commands = %w[
+  #  bind
+  #  call
+  #  cd
+  #  do
+  #  evaluate
+  #  fit
+  #  history
+  #  if
+  #  print
+  #  pwd
+  #  reread
+  #  save
+  #  shell
+  #  stats
+  #  system
+  #  test
+  #  update
+  #  while
+  #]
+
+  # for irb workspace name
+  def to_s
+    "gnuplot"
+  end
+
+  def run(s)
+    res = send_cmd(s)
+    if !res.empty?
+      if res.size > 7
+        msg = "\n"+res[0..5].join("")+" :\n"
+      else
+        msg = "\n"+res.join("")
+      end
+      kernel_raise GnuplotError,msg
+    end
+    nil
+  end
+  private :run
+
+  def send_cmd(s)
+    puts "<"+s if @debug
+    @iow.puts s
+    @iow.flush
+    @iow.puts "print '_end_of_cmd_'"
+    @iow.flush
+    @history << s
+    res = []
+    while line=@ior.gets
+      puts ">"+line if @debug
+      break if /^_end_of_cmd_$/ =~ line
+      res << line
+    end
+    res # = res.chomp.strip
+  end
+  private :send_cmd
+
+  def parse_plot_args(args)
+    list = [[]]
+    item = PlotItem.new
+    list << item
+    args.each do |arg|
+      case arg
+      when Range
+        list.first << arg
+      when Array
+        if arg.all?{|e| e.kind_of?(Range)}
+          list.first.concat(arg)
+        elsif PlotItem.is_data(arg)
+          item << arg
+        else
+          if list.last.empty?
+            list.pop
+          end
+          item = PlotItem.new(*arg)
+          list << item
+        end
+      when Hash
+        item << arg
+        item = PlotItem.new
+        list << item
+      else
+        item << arg
+      end
+    end
+    if list.last.empty?
+      list.pop
+    end
+    return list
+  end
+  private :parse_plot_args
+
+
+  # @private
+  class OptsToS # :nodoc: all
+    def initialize(*opts)
+      @opts = opts
+    end
+
+    def to_s
+      opts_to_s(*@opts)
+    end
+
+    def opts_to_s(*opts)
+      #p opts
+      sep = ","
+      opts.map do |opt|
+        sep = " " if !opt.kind_of?(Numeric)
+        case opt
+        when Array
+          opt.map{|v| "#{opts_to_s(*v)}"}.join(sep)
+        when Hash
+          opt.map{|k,v| KvItem.new(k,v).to_s}.compact.join(" ")
+        when Range
+          "[#{opt.begin}:#{opt.end}]"
+        else
+          opt.to_s
+        end
+      end.join(sep)
+    end
+  end
+
+  # @private
+  class KvItem # :nodoc: all
+    NEED_QUOTE = %w[
+      background
+      cblabel
+      clabel
+      dashtype
+      dt
+      font
+      format
+      format_cb
+      format_x
+      format_x2
+      format_xy
+      format_y
+      format_y2
+      format_z
+      output
+      rgb
+      timefmt
+      title
+      x2label
+      xlabel
+      y2label
+      ylabel
+      zlabel
+    ].map{|x| x.to_sym}
+
+    def initialize(k,v)
+      @k = k
+      @v = v
+    end
+
+    def need_quote?(k)
+      NEED_QUOTE.any? do |q|
+        /^#{k}/ =~ q
+      end
+    end
+
+    def to_s
+      kv_to_s(@k,@v)
+    end
+
+    def kv_to_s(k,v)
+      if need_quote?(k)
+        case v
+        when String
+          "#{k} #{v.inspect}"
+        when Array
+          "#{k} #{v[0].inspect} #{OptsToS.new(*v[1..-1])}"
+        end
+      else
+        case v
+        when String
+          "#{k} #{v}"
+        when TrueClass
+          "#{k}"
+        when NilClass
+          nil
+        when FalseClass
+          nil
+        when Array
+          "#{k} #{OptsToS.new(*v)}"
+        else
+          "#{k} #{OptsToS.new(v)}"
+        end
+      end
+    end
+  end # KvItem
+
+
+  # @private
+  class PlotItem # :nodoc: all
+
+    def self.is_data(a)
+      if a.kind_of? Array
+        if a.last.kind_of?(Hash)
+          return false
+        else
+          t = a.first.class
+          t = Numeric if t < Numeric
+          return a.all?{|e| e.kind_of?(t)}
+        end
+      elsif defined?(Numo::NArray)
+        return true if a.kind_of?(Numo::NArray)
+      elsif defined?(NArray)
+        return true if a.kind_of?(NArray)
+      elsif defined?(NMatrix)
+        return true if a.kind_of?(NMatix)
+      end
+      false
+    end
+
+    def initialize(*items)
+      @items = items
+    end
+
+    def <<(item)
+      @items << item
+    end
+
+    def empty?
+      @items.empty?
+    end
+
+    def parse_items
+      if !@options
+        if @items.empty?
+          return
+        elsif @items.first.kind_of? String
+          @function = @items.first
+          @options = @items[1..-1]
+        else
+          @data = []
+          @options = []
+          @items.each do |x|
+            if PlotItem.is_data(x)
+              @data << x
+            else
+              @options << x
+            end
+          end
+          if @data.size==1
+            a = @data[0]
+            if a.respond_to?(:shape)
+              if a.shape.size == 2
+                @matrix = true
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def cmd_str
+      parse_items
+      if @function
+        "%s %s" % [@function, OptsToS.new(*@options)]
+      else
+        if @matrix
+          "'-' matrix %s" % OptsToS.new(*@options)
+        else
+          "'-' %s" % OptsToS.new(*@options)
+        end
+      end
+    end
+
+    def data_str
+      parse_items
+      if @function
+        nil
+      else
+        if @matrix
+          data2d_to_s(@data[0])+"\ne\n"
+        else
+          data1d_to_s(@data)+"e\n"
+        end
+      end
+    end
+
+    def data_format
+      @data_format || DATA_FORMAT
+    end
+
+    def data_format=(s)
+      @data_format = s
+    end
+
+    def data1d_to_s(a)
+      n = a.map{|e| e.size}.min
+      f = ([data_format]*a.size).join(" ")+"\n"
+      s = ""
+      n.times{|i| s << f % a.map{|e| e[i]}}
+      s
+    end
+
+    def data2d_to_s(a)
+      f = data_format
+      s = ""
+      a.to_a.each do |b|
+        s << b.map{|e| f%e}.join(" ")+"\n"
+      end
+      s
+    end
+  end # PlotItem
+end # Numo::Gnuplot
+end