daru 0.1.3.1 → 0.1.4

data/lib/daru/monkeys.rb

@@ -1,28 +1,4 @@
 class Array
-  # Recode repeated values on an array, adding the number of repetition
-  # at the end
-  # Example:
-  #   a=%w{a b c c d d d e}
-  #   a.recode_repeated
-  #   => ["a","b","c_1","c_2","d_1","d_2","d_3","e"]
-  def recode_repeated
-    return self if size == uniq.size
-
-    duplicated = group_by { |n| n }
-                 .select { |_, g| g.size > 1 }.map(&:first)
-
-    counter = duplicated.collect { |n| [n, 0] }.to_h
-
-    collect do |n|
-      if counter.key?(n)
-        counter[n] += 1
-        '%s_%d' % [n, counter[n]]
-      else
-        n
-      end
-    end
-  end
-
   def daru_vector name=nil, index=nil, dtype=:array
     Daru::Vector.new self, name: name, index: index, dtype: dtype
   end
@@ -54,6 +30,7 @@ class Hash
   alias_method :dv, :daru_vector
 end
 
+# :nocov:
 class NMatrix
   def daru_vector(name=nil, index=nil, *)
     Daru::Vector.new self, name: name, index: index, dtype: :nmatrix
@@ -70,12 +47,6 @@ class MDArray
   alias_method :dv, :daru_vector
 end
 
-class Numeric
-  def square
-    self * self
-  end
-end
-
 class Matrix
   def elementwise_division other
     map.with_index do |e, index|
@@ -84,17 +55,18 @@ class Matrix
   end
 end
 
-class String
-  def is_number?
-    if self =~ /^-?\d+[,.]?\d*(e-?\d+)?$/
-      true
-    else
-      false
+class Object
+  if RUBY_VERSION < '2.2'
+    def itself
+      self
     end
   end
 end
 
-class Daru::DataFrame
-  # NOTE: This alias will soon be removed. Use to_h in all future work.
-  alias :to_hash :to_h
-end
+module Daru
+  class DataFrame
+    # NOTE: This alias will soon be removed. Use to_h in all future work.
+    alias :to_hash :to_h
+  end
+end
+# :nocov:

data/lib/daru/plotting/gruff.rb

@@ -0,0 +1,3 @@
+require_relative 'gruff/category.rb'
+require_relative 'gruff/vector.rb'
+require_relative 'gruff/dataframe.rb'

data/lib/daru/plotting/gruff/category.rb

@@ -0,0 +1,49 @@
+module Daru
+  module Plotting
+    module Category
+      module GruffLibrary
+        def plot opts={}
+          type = opts[:type] || :bar
+          size = opts[:size] || 500
+          case type
+          when :bar, :pie, :sidebar
+            plot = send("category_#{type}_plot".to_sym, size, opts[:method])
+          else
+            raise ArgumentError, 'This type of plot is not supported.'
+          end
+          yield plot if block_given?
+          plot
+        end
+
+        private
+
+        def category_bar_plot size, method
+          plot = Gruff::Bar.new size
+          method ||= :count
+          dv = frequencies(method)
+          plot.labels = size.times.to_a.zip(dv.index.to_a).to_h
+          plot.data name || :vector, dv.to_a
+          plot
+        end
+
+        def category_pie_plot size, method
+          plot = Gruff::Pie.new size
+          method ||= :count
+          frequencies(method).each_with_index do |data, index|
+            plot.data index, data
+          end
+          plot
+        end
+
+        def category_sidebar_plot size, method
+          plot = Gruff::SideBar.new size
+          plot.labels = {0 => (name.to_s || 'vector')}
+          frequencies(method).each_with_index do |data, index|
+            plot.data index, data
+          end
+          plot
+        end
+      end
+    end
+  end
+end

data/lib/daru/plotting/gruff/dataframe.rb

@@ -0,0 +1,91 @@
+module Daru
+  module Plotting
+    module DataFrame
+      module GruffLibrary
+        def plot opts={}
+          type = opts[:type] || :bar
+          size = opts[:size] || 500
+          x = extract_x_vector opts[:x]
+          y = extract_y_vectors opts[:y]
+          return plot_with_category(
+            size, type, x, y, opts[:categorized]
+          ) if opts[:categorized]
+          case type
+          when :line, :bar, :scatter
+            plot = send("#{type}_plot", size, x, y)
+          # TODO: hist, box
+          # It turns out hist and box are not supported in Gruff yet
+          else
+            raise ArgumentError, 'This type of plot is not supported.'
+          end
+          yield plot if block_given?
+          plot
+        end
+
+        private
+
+        def line_plot size, x, y
+          plot = Gruff::Line.new size
+          plot.labels = size.times.to_a.zip(x).to_h
+          y.each do |vec|
+            plot.data vec.name || :vector, vec.to_a
+          end
+          plot
+        end
+
+        def bar_plot size, x, y
+          plot = Gruff::Bar.new size
+          plot.labels = size.times.to_a.zip(x).to_h
+          y.each do |vec|
+            plot.data vec.name || :vector, vec.to_a
+          end
+          plot
+        end
+
+        def scatter_plot size, x, y
+          plot = Gruff::Scatter.new size
+          y.each do |vec|
+            plot.data vec.name || :vector, x, vec.to_a
+          end
+          plot
+        end
+
+        def plot_with_category size, type, x, y, opts
+          x = Daru::Vector.new x
+          y = y.first
+          case type
+          when :scatter
+            plot = Gruff::Scatter.new size
+            cat_dv = self[opts[:by]]
+            cat_dv.categories.each do |cat|
+              bools = cat_dv.eq cat
+              plot.data cat, x.where(bools).to_a, y.where(bools).to_a
+            end
+          else
+            raise ArgumentError, "Type #{type} is not supported."
+          end
+          yield plot if block_given?
+          plot
+        end
+
+        def extract_x_vector x_name
+          x_name && self[x_name].to_a || index.to_a
+        end
+
+        def extract_y_vectors y_names
+          y_names =
+            case y_names
+            when nil
+              vectors.to_a
+            when Array
+              y_names
+            else
+              [y_names]
+            end
+
+          y_names.map { |y| self[y] }.select(&:numeric?)
+        end
+      end
+    end
+  end
+end

data/lib/daru/plotting/gruff/vector.rb

@@ -0,0 +1,57 @@
+module Daru
+  module Plotting
+    module Vector
+      module GruffLibrary
+        def plot opts={}
+          type = opts[:type] || :bar
+          size = opts[:size] || 500
+          case type
+          when :line, :bar, :pie, :scatter, :sidebar
+            plot = send("#{type}_plot", size)
+          # TODO: hist, box
+          # It turns out hist and box are not supported in Gruff yet
+          else
+            raise ArgumentError, 'This type of plot is not supported.'
+          end
+          yield plot if block_given?
+          plot
+        end
+
+        private
+
+        def line_plot size
+          plot = Gruff::Line.new size
+          plot.labels = size.times.to_a.zip(index.to_a).to_h
+          plot.data name || :vector, to_a
+          plot
+        end
+
+        def bar_plot size
+          plot = Gruff::Bar.new size
+          plot.labels = size.times.to_a.zip(index.to_a).to_h
+          plot.data name || :vector, to_a
+          plot
+        end
+
+        def pie_plot size
+          plot = Gruff::Pie.new size
+          each_with_index { |data, index| plot.data index, data }
+          plot
+        end
+
+        def scatter_plot size
+          plot = Gruff::Scatter.new size
+          plot.data name || :vector, index.to_a, to_a
+          plot
+        end
+
+        def sidebar_plot size
+          plot = Gruff::SideBar.new size
+          plot.labels = {0 => (name.to_s || 'vector')}
+          each_with_index { |data, index| plot.data index, data }
+          plot
+        end
+      end
+    end
+  end
+end

data/lib/daru/plotting/nyaplot.rb

@@ -0,0 +1,3 @@
+require_relative 'nyaplot/category.rb'
+require_relative 'nyaplot/vector.rb'
+require_relative 'nyaplot/dataframe.rb'

data/lib/daru/plotting/nyaplot/category.rb

@@ -0,0 +1,34 @@
+module Daru
+  module Plotting
+    module Category
+      module NyaplotLibrary
+        def plot opts
+          case type = opts[:type]
+          when :bar
+            plot = Nyaplot::Plot.new
+            opts[:method] ||= :count
+            values = frequencies opts[:method]
+            diagram = plot.add :bar, values.index.to_a, values.to_a
+            # Set yrange for good view
+            set_yrange plot, opts[:method]
+            yield plot, diagram if block_given?
+            plot.show
+          else
+            raise ArgumentError, "#{type} type is not supported."
+          end
+        end
+
+        private
+
+        def set_yrange plot, method
+          case method
+          when :percentage
+            plot.yrange [0, 100]
+          when :fraction
+            plot.yrange [0, 1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daru/plotting/nyaplot/dataframe.rb

@@ -0,0 +1,187 @@
+module Daru
+  module Plotting
+    module DataFrame
+      module NyaplotLibrary
+        # Plots a DataFrame with Nyaplot on IRuby using the given options. Yields
+        # the corresponding Nyaplot::Plot object and the Nyaplot::Diagram object
+        # to the block, if it is specified. See the nyaplot docs for info on how to
+        # further use these objects.
+        #
+        # Detailed instructions on use of the plotting API can be found in the
+        # notebooks whose links you can find in the README.
+        #
+        # == Options
+        #
+        # * +:type+  - Type of plot. Can be :scatter, :bar, :histogram, :line or :box.
+        # * +:x+ - Vector to be used for X co-ordinates.
+        # * +:y+ - Vector to be used for Y co-ordinates.
+        #
+        # == Usage
+        #   # Simple bar chart
+        #   df = Daru::DataFrame.new({a:['A', 'B', 'C', 'D', 'E'], b:[10,20,30,40,50]})
+        #   df.plot type: :bar, x: :a, y: :b
+        def plot opts={}, &block
+          if opts[:categorized]
+            plot_with_category(opts, &block)
+          else
+            plot_without_category(opts, &block)
+          end
+        end
+
+        private
+
+        def plot_without_category opts
+          options = {type:  :scatter}.merge(opts)
+
+          plot = Nyaplot::Plot.new
+          types = extract_option :type, options
+
+          diagram =
+            case
+            when !([:scatter, :bar, :line, :histogram] & types).empty?
+              plot_regular_diagrams plot, opts
+            when types.include?(:box)
+              plot_box_diagram plot
+            else
+              raise ArgumentError, "Unidentified plot types: #{types}"
+            end
+
+          yield(plot, diagram) if block_given?
+
+          plot.show
+        end
+
+        def plot_with_category opts
+          case type = opts[:type]
+          when :scatter, :line
+            plot = Nyaplot::Plot.new
+            category_opts = opts[:categorized]
+            type = opts[:type]
+            x, y = opts[:x], opts[:y]
+            cat_dv = self[category_opts[:by]]
+
+            diagrams = create_categorized_diagrams plot, cat_dv, x, y, type
+
+            apply_variant_to_diagrams diagrams, category_opts, type
+
+            plot.legend true
+            yield plot, *diagrams if block_given?
+            plot.show
+
+          else
+            raise ArgumentError, "Unsupported type #{type}"
+          end
+        end
+
+        def create_categorized_diagrams plot, cat_dv, x, y, type
+          cat_dv.categories.map do |cat|
+            x_vec = self[x].where(cat_dv.eq cat)
+            y_vec = self[y].where(cat_dv.eq cat)
+            df = Daru::DataFrame.new [x_vec, y_vec], order: [x, y]
+            nyaplot_df = df.to_nyaplotdf
+
+            plot.add_with_df(nyaplot_df, type, x, y)
+          end
+        end
+
+        def apply_variant_to_diagrams diagrams, category_opts, type
+          method = category_opts[:method]
+          cat_dv = self[category_opts[:by]]
+          # If user has mentioned custom color, size, shape use them
+          variant =
+            if category_opts[method]
+              category_opts[method].cycle
+            else
+              send("get_#{method}".to_sym, type)
+            end
+
+          diagrams.zip(cat_dv.categories) do |d, cat|
+            d.title cat
+            d.send(method, variant.next)
+            d.tooltip_contents [cat]*cat_dv.count(cat) if type == :scatter
+          end
+        end
+
+        SHAPES = %w(circle triangle-up diamond square triangle-down cross).freeze
+        def get_shape type
+          validate_type type, :scatter
+          SHAPES.cycle
+        end
+
+        def get_size type
+          validate_type type, :scatter
+          (50..550).step(100).cycle
+        end
+
+        def get_color(*)
+          Nyaplot::Colors.qual.cycle
+        end
+
+        def get_stroke_width type
+          validate_type type, :line
+          (2..16).step(2).cycle
+        end
+
+        def validate_type type, *types
+          raise ArgumentError, "Invalid option for #{type} type" unless
+            types.include? type
+        end
+
+        def single_diagram? options
+          options[:x] && options[:x].is_a?(Symbol)
+        end
+
+        def plot_regular_diagrams plot, opts
+          if single_diagram? opts
+            add_single_diagram plot, opts
+          else
+            add_multiple_diagrams plot, opts
+          end
+        end
+
+        def plot_box_diagram plot
+          numeric = only_numerics(clone: false).reject_values(*Daru::MISSING_VALUES)
+          plot.add_with_df(numeric.to_nyaplotdf, :box, *numeric.vectors.to_a)
+        end
+
+        def add_single_diagram plot, options
+          args = [
+            to_nyaplotdf,
+            options[:type],
+            options[:x]
+          ]
+
+          args << options[:y] if options[:y]
+
+          plot.add_with_df(*args)
+        end
+
+        def add_multiple_diagrams plot, options
+          types  = extract_option :type, options
+          x_vecs = extract_option :x, options
+          y_vecs = extract_option :y, options
+
+          nyaplot_df = to_nyaplotdf
+          total      = x_vecs.size
+          types      = types.size < total ? types*total : types
+
+          types.zip(x_vecs, y_vecs).map do |t, xv, yv|
+            plot.add_with_df(nyaplot_df, t, xv, yv)
+          end
+        end
+
+        def extract_option opt, options
+          if options[opt]
+            o = options[opt]
+            o.is_a?(Array) ? o : [o]
+          else
+            options.keys
+                   .select { |a| a =~ Regexp.new("\\A#{opt}") }
+                   .sort
+                   .map { |a| options[a] }
+          end
+        end
+      end
+    end
+  end
+end