daru 0.0.3.1 → 0.0.4

data/lib/daru/index.rb

@@ -14,17 +14,27 @@ module Daru
 
     attr_reader :index_class
 
-    def initialize index
+    def initialize index, values=nil
       @relation_hash = {}
 
       index = 0                         if index.nil?
       index = Array.new(index) { |i| i} if index.is_a? Integer
 
-      index.each_with_index do |n, idx|
-        n = n.to_sym unless n.is_a?(Integer)
+      if values.nil?
+        index.each_with_index do |n, idx|
+          n = n.to_sym unless n.is_a?(Integer)
 
-        @relation_hash[n] = idx 
+          @relation_hash[n] = idx 
+        end
+      else
+        raise IndexError, "Size of values : #{values.size} and index : #{index.size} do not match" if
+          index.size != values.size
+
+        values.each_with_index do |value,i|
+          @relation_hash[index[i]] = value
+        end
       end
+
       @relation_hash.freeze
 
       @size = @relation_hash.size
@@ -43,7 +53,21 @@ module Daru
     end
 
     def [](key)
-      @relation_hash[key]
+      case key
+      when Range
+        first = @relation_hash[key.first]
+        last  = @relation_hash[key.last]
+
+        indexes = []
+
+        (first..last).each do |idx|
+          indexes << @relation_hash.key(idx)
+        end
+
+        Daru::Index.new indexes, (first..last).to_a
+      else
+        @relation_hash[key]
+      end
     end
 
     def +(other)

data/lib/daru/io/io.rb

@@ -16,7 +16,7 @@ module Daru
 
         csv.each_with_index do |row, index|
           if first
-            df    = Daru::DataFrame.new({}, vectors: csv.headers)
+            df    = Daru::DataFrame.new({}, order: csv.headers, name: opts[:name])
             first = false
           end
 

data/lib/daru/{math → maths}/arithmetic/dataframe.rb

@@ -1,5 +1,5 @@
 module Daru
-  module Math
+  module Maths
     module Arithmetic
       module DataFrame
         

data/lib/daru/maths/arithmetic/vector.rb

@@ -0,0 +1,75 @@
+module Daru
+  module Maths
+    module Arithmetic
+      module Vector
+        def + other
+          binary_op :+, other
+        end
+
+        def - other
+          binary_op :-, other
+        end
+
+        def * other
+          binary_op :*, other
+        end
+
+        def / other
+          binary_op :/, other
+        end
+
+        def % other
+          binary_op :%, other
+        end
+
+        def ** other
+          binary_op :**, other
+        end
+
+        def exp
+          
+        end
+
+        def sqrt
+          
+        end
+
+        def round
+          
+        end
+
+       private
+
+        def binary_op operation, other
+          case other
+          when Daru::Vector
+            v2v_binary operation, other
+          else
+            v2o_binary operation, other
+          end
+        end
+
+        def v2o_binary operation, other
+          Daru::Vector.new self.map { |e| e.send(operation, other) }, name: @name, index: @index
+        end
+
+        def v2v_binary operation, other
+          common_idxs = []
+          elements    = []
+
+          @index.each do |idx|
+            this = self[idx]
+            that = other[idx]
+
+            if this and that
+              elements << this.send(operation ,that)
+              common_idxs << idx
+            end
+          end
+
+          Daru::Vector.new(elements, name: @name, index: common_idxs)
+        end
+      end
+    end
+  end
+end

data/lib/daru/{math → maths}/statistics/dataframe.rb

@@ -1,5 +1,5 @@
 module Daru
-  module Math
+  module Maths
     module Statistics
       module DataFrame
         

data/lib/daru/maths/statistics/vector.rb

@@ -0,0 +1,147 @@
+module Daru
+  module Maths
+    module Statistics
+      module Vector
+
+        def mean
+          @vector.mean
+        end
+
+        def median
+          @vector.median
+        end
+
+        def mode
+          @vector.mode
+        end
+
+        def sum
+          @vector.sum
+        end
+
+        def product
+          @vector.product
+        end
+
+        def median_absolute_deviation
+          @vector.median_absolute_deviation  
+        end
+
+        def standard_error
+          @vector.standard_error
+        end
+
+        def sum_of_squared_deviation
+          @vector.sum_of_squared_deviation
+        end
+
+        # Maximum element of the vector.
+        # 
+        # @param return_type [Symbol] Data type of the returned value. Defaults
+        # to returning only the maximum number but passing *:vector* will return
+        # a Daru::Vector with the index of the corresponding maximum value.
+        def max return_type=:stored_type
+          max_value = @vector.max
+          if return_type == :vector
+            Daru::Vector.new({index_of(max_value) => max_value}, name: @name, dtype: @dtype)
+          else
+            max_value
+          end
+        end
+
+        def min
+          @vector.min
+        end
+
+        def has_missing_data?
+          @vector.has_missing_data?
+        end
+
+        def range
+          @vector.range
+        end
+
+        def frequencies
+          @vector.frequencies
+        end
+
+        def proportions
+          @vector.proportions
+        end
+
+        def ranked
+          @vector.ranked
+        end
+
+        def coefficient_of_variation
+          @vector.coefficient_of_variation
+        end
+
+        # Retrieves number of cases which comply condition.
+        # If block given, retrieves number of instances where
+        # block returns true.
+        # If other values given, retrieves the frequency for
+        # this value.
+        def count value=false
+          @vector.count value
+        end
+
+        def proportion value=1
+          @vector.proportion value
+        end
+
+        # Population variance with denominator (N)
+        def variance_population m=nil
+          @vector.variance_population m
+        end
+
+        # Sample variance with denominator (N-1)
+        def variance_sample m=nil
+          @vector.variance_sample m
+        end
+
+        def sum_of_squares m=nil
+          @vector.sum_of_squares m
+        end
+
+        def standard_deviation_sample m=nil
+          @vector.standard_deviation_sample m
+        end
+
+        def standard_deviation_population m=nil
+          @vector.standard_deviation_population m
+        end
+
+        # Calculate skewness using (sigma(xi - mean)^3)/((N)*std_dev_sample^3)
+        def skew m=nil
+          @vector.skew m
+        end
+
+        def kurtosis m=nil
+          @vector.kurtosis m
+        end
+
+        def average_deviation_population m=nil
+          @vector.average_deviation_population m
+        end
+
+        def recode!(&block)
+          @vector.recode!(&block)
+        end
+
+        def percentile percent
+          @vector.percentile percent
+        end
+
+        alias_method :sdp, :standard_deviation_population
+        alias_method :sds, :standard_deviation_sample
+        alias_method :adp, :average_deviation_population
+        # alias_method :cov, :coefficient_of_variation
+        # alias_method :variance, :variance_sample    
+        alias_method :sd, :standard_deviation_sample
+        alias_method :ss, :sum_of_squares
+        alias_method :percentil, :percentile
+      end
+    end
+  end
+end

data/lib/daru/monkeys.rb

@@ -1,6 +1,6 @@
 class Array
-  def daru_vector name=nil, index=nil
-    Daru::Vector.new self, name: name, index: index
+  def daru_vector name=nil, index=nil, dtype=Array
+    Daru::Vector.new self, name: name, index: index, dtype: dtype
   end
 
   alias_method :dv, :daru_vector
@@ -11,8 +11,8 @@ class Array
 end
 
 class Range
-  def daru_vector name=nil, index=nil
-    Daru::Vector.new self, name: name, index: index
+  def daru_vector name=nil, index=nil, dtype=Array
+    Daru::Vector.new self, name: name, index: index, dtype: Array
   end
 
   alias_method :dv, :daru_vector
@@ -23,25 +23,31 @@ class Range
 end
 
 class Hash
-  def daru_vector index=nil
-    Daru::Vector.new self.values[0], name: self.keys[0], index: index
+  def daru_vector index=nil, dtype=Array
+    Daru::Vector.new self.values[0], name: self.keys[0], index: index, dtype: Array
   end
 
   alias_method :dv, :daru_vector
 end
 
 class NMatrix
-  def daru_vector name=nil, index=nil
-    Daru::Vector.new self, name: name, index: index
+  def daru_vector name=nil, index=nil, dtype=NMatrix
+    Daru::Vector.new self, name: name, index: index, dtype: NMatrix
   end
 
   alias_method :dv, :daru_vector
 end
 
 class MDArray
-  def daru_vector name=nil, index=nil
-    Daru::Vector.new self, name: name, index: index
+  def daru_vector name=nil, index=nil, dtype=MDArray
+    Daru::Vector.new self, name: name, index: index, dtype: MDArray
   end
 
   alias_method :dv, :daru_vector
+end
+
+class Numeric
+  def square
+    self * self
+  end
 end

data/lib/daru/plotting/dataframe.rb

@@ -0,0 +1,47 @@
+begin
+  require 'nyaplot'
+rescue LoadError => e
+  puts "#{e}"
+end
+
+module Daru
+  module Plotting
+    module DataFrame
+      # Plots a DataFrame with Nyaplot on IRuby using the given options.
+      # == Arguments
+      #   +x+ - Vector name to be used for x-axis
+      #   +y+ - Vector name to be used for y-axis
+      # == Options
+      #   type    - Type of plot (scatter, bar, histogram)
+      #   title   - Title of plot
+      #   x_label - X - label
+      #   y_label - Y - label
+      #   tooltip_contents - Contents of the tooltip. Array of vector names
+      #   fill_by - Vector name by which each plotted element is colored 
+      #   shape_by- Vector name by which dots in a scatter plot are shaped
+      # == Usage
+      #   df = Daru::DataFrame.new({a:[0,1,2,3,4], b:[10,20,30,40,50]})
+      #   df.plot :a, :b, type: :bar, title: "Awesome plot"
+      def plot x, y, opts={}
+        options = {
+          type:  :scatter,
+          title: "#{@name}",
+        }.merge(opts)
+
+        plot = Nyaplot::Plot.new
+        p    = plot.add_with_df(Nyaplot::DataFrame.new(self.to_a[0]), options[:type], x, y)
+        plot.x_label options[:x_label]                if options[:x_label]
+        plot.y_label options[:y_label]                if options[:y_label]
+        p.tooltip_contents options[:tooltip_contents] if options[:tooltip_contents]
+
+        if options[:fill_by] or options[:shape_by]
+          p.color Nyaplot::Colors.qual
+          p.fill_by  options[:fill_by]  if options[:fill_by]
+          p.shape_by options[:shape_by] if options[:shape_by]
+        end
+
+        plot.show
+      end
+    end
+  end
+end

data/lib/daru/plotting/vector.rb

@@ -0,0 +1,41 @@
+begin
+  require 'nyaplot'
+rescue LoadError => e
+  puts "#{e}"
+end
+
+module Daru
+  module Plotting
+    module Vector
+
+      # Plots a Vector with Nyaplot on IRuby using the given options.
+      # == Options
+      #   type (:scatter, :bar, :histogram), title, x_label, y_label, color(true/false)
+      # 
+      # == Usage
+      #   vector = Daru::Vector.new [10,20,30,40], [:one, :two, :three, :four]
+      #   vector.plot type: :bar, title: "My first plot", color: true
+      def plot opts={}
+        options = {
+          type: :scatter,
+          title: "#{@name}",
+          x_label: '',
+          y_label: '',
+          color: false
+        }.merge(opts)
+
+        x_axis = options[:type] == :scatter ? Array.new(@size) { |i| i } : @index.to_a
+        plot   = Nyaplot::Plot.new
+        plot.width(options[:width])   if options[:width]
+        plot.height(options[:height]) if options[:height]
+        
+        p      = plot.add( options[:type], x_axis, @vector.to_a )
+        plot.x_label( options[:x_label] )  if options[:x_label]
+        plot.y_label( options[:y_label] )  if options[:y_label]
+        p.color( Nyaplot::Colors.qual )    if options[:color]
+
+        plot.show
+      end
+    end
+  end
+end