mikon 0.1.0.rc1

data/lib/mikon/core/index.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+module Mikon
+  # Internal class for indexing
+  class Index
+    extend Forwardable
+    def_delegators :@data, :[]
+
+    def initialize(source, options={})
+      options = {
+        name: nil
+      }.merge(options)
+
+      case
+      when source.is_a?(Array)
+        @data = Mikon::DArray.new(source)
+      when source.is_a?(Mikon::DArray)
+        @data = source
+      else raise ArgumentError
+      end
+
+      @name = options[:name]
+    end
+
+    def sort_by(&block)
+      return self.to_enum(:sort_by) unless block_given?
+      Mikon::Index.new(@data.sort_by(&block))
+    end
+  end
+end

data/lib/mikon/core/series.rb

@@ -0,0 +1,139 @@
+require 'forwardable'
+
+module Mikon
+  class Series
+    include Enumerable
+    extend Forwardable
+    def_delegators :@data, :max, :min
+    def_delegators :@data, *(Mikon::Stats.instance_methods)
+    attr_reader :index, :name
+
+    def initialize(name, source, options={})
+      options = {
+        index: nil
+      }.merge(options)
+
+      case
+      when source.is_a?(Array) || source.is_a?(NMatrix)
+        @data = Mikon::DArray.new(source)
+      when source.is_a?(Mikon::DArray)
+        @data = source
+      else
+        raise "Non-acceptable Arguments Error"
+      end
+
+      @index = options[:index]
+      @name = name
+
+      _check_if_valid
+    end
+
+    def _check_if_valid
+      @index = (0..(length-1)).to_a if @index.nil?
+      raise "index should have the same length as arrays" if @index.length != @data.length
+    end
+
+    def length
+      @data.length
+    end
+
+    def each(&block)
+      @data.each(&block)
+    end
+
+    def [](arg)
+      pos = @index.index(arg)
+      raise "There is no index named" + arg.to_s if pos.nil?
+      @data[pos]
+    end
+
+    def to_html(threshold=5)
+      html = "<table><tr><th></th><th>" + self.name.to_s + "</th></tr>"
+      @index.each.with_index do |index, pos|
+        next if pos > threshold && pos != self.length-1
+        html += "<tr><th>" + index.to_s + "</th><td>" + @data[pos].to_s + "</td></tr>"
+        html += "<tr><th>...</th><td>...</td></tr>" if pos == threshold
+      end
+      html + "</table>"
+    end
+
+    def to_s(threshold=5)
+      arr = []
+      @index.each.with_index do |index, pos|
+        next nil if pos > threshold && pos != self.length-1
+        arr.push({"" => index, @name => @data[pos]})
+        arr.push({"" => "...", @name => "..."}) if pos == threshold
+      end
+      Formatador.display_table(arr.select{|el| !(el.nil?)})
+    end
+
+    def name(new_name=nil)
+      if new_name.nil?
+        @name
+      else
+        @name = new_name
+        self
+      end
+    end
+
+    def to_a
+      @data.to_a
+    end
+
+    def to_darr
+      @data
+    end
+
+    def *(arg)
+      if arg.is_a?(Numeric)
+        Series.new(self.name, @data*arg, index: self.index)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def /(arg)
+      if arg.is_a?(Numeric)
+        Series.new(self.name, @data/arg, index: self.index)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def %(arg)
+      if arg.is_a?(Numeric)
+        Series.new(self.name, @data%arg, index: self.index)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def -(arg)
+      if arg.is_a?(Mikon::Series) && arg.length == self.length
+        Series.new(self.name, arg.coerce(@data).inject(:-), index: self.index)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def +(arg)
+      if arg.is_a?(Mikon::Series) && arg.length == self.length
+        Series.new(self.name, arg.coerce(@data).inject(:+), index: self.index)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def coerce(other)
+      if other.is_a?(Mikon::DArray)
+        return other, @data
+      elsif other.is_a?(Numeric)
+        return self, other
+      else
+        raise ArgumentError
+      end
+    end
+
+    private :_check_if_valid
+  end
+end

data/lib/mikon/pivot.rb

@@ -0,0 +1,36 @@
+module Mikon
+  class DataFrame
+    # Experimental Implementation.
+    # DO NOT USE THIS METHOD
+    def pivot(args={})
+      args = {
+        column: nil,
+        row: nil,
+        value: nil,
+        fill_value: Float::NAN
+      }.merge(args)
+
+      raise ArgumentError unless [:column, :row, :value].all?{|sym| args[sym].is_a?(Symbol)}
+
+      column = self[args[:column]].factors
+      index = self[args[:row]].factors
+
+      source = column.reduce({}) do |memo, label|
+        arr = []
+        df = self.select{|row| row[args[:column]] == label}
+        index.each do |i|
+          unless df.any?{|row| row[args[:row]] == i}
+            arr.push(args[:fill_value])
+          else
+            column = df.select{|row| row[args[:row]] == i}[args[:value]]
+            arr.push(column.to_a[0])
+          end
+        end
+        memo[label] = arr
+        memo
+      end
+
+      Mikon::DataFrame.new(source, index: index)
+    end
+  end
+end

data/lib/mikon/plot.rb

@@ -0,0 +1,66 @@
+require 'nyaplot'
+
+module Mikon
+  class Series
+    def plot(args={})
+      args = {
+        :type => :histogram
+      }.merge(args)
+
+      plot = Nyaplot::Plot.new
+
+      case args[:type]
+      when :histogram
+        plot.add(:histogram, @data.to_a)
+      when :line
+        plot.add(:line, @index, @data.to_a)
+      end
+
+      plot
+    end
+  end
+
+  class DataFrame
+    def plot(args={})
+      args = {
+        :type => :line,
+        :x => nil,
+        :y => nil,
+        :fill_by => nil,
+        :color => nil
+      }.merge(args)
+
+      plot = Nyaplot::Plot.new
+      plot.x_label("")
+      plot.y_label("")
+
+      unless args[:color].nil?
+        colors = Nyaplot::Colors.send(args[:color]).to_a
+      else
+        colors = Nyaplot::Colors.qual.to_a
+      end
+
+      case args[:type]
+      when :line
+        @data.each.with_index do |darr, i|
+          line = plot.add(:line, @index, darr.to_a)
+          line.color(colors.pop)
+          line.title(@labels[i])
+        end
+        plot.legend(true)
+
+      when :box
+        plot.add_with_df(self, :box, *@labels)
+
+      when :scatter
+        sc = plot.add_with_df(self, :scatter, args[:x], args[:y])
+        sc.color(colors)
+        sc.fill_by(args[:fill_by]) unless args[:fill_by].nil?
+        plot.x_label(args[:x])
+        plot.y_label(args[:y])
+      end
+
+      plot
+    end
+  end
+end

data/lib/mikon/stats.rb

@@ -0,0 +1,227 @@
+require 'forwardable'
+
+# Implementation of statistical functions. Make DArray compatible with Statsample::Vector.
+#
+module Mikon
+  module Stats
+    extend Forwardable
+    def_delegators :@data, :size, :max, :min, :push, :sorted_indices
+
+    def average_deviation_population(m=nil)
+      m ||= self.mean
+      (self.reduce(0){|memo, val| val + (val - m).abs})/self.length
+    end
+
+    def coefficient_of_variation
+      self.standard_deviation_sample/self.mean
+    end
+
+    def count(x=false)
+      if block_given?
+        self.reduce(0){|memo, val| memo += 1 if yield val; memo}
+      else
+        val = self.frequencies[x]
+        val.nil? ? 0 : val
+      end
+    end
+
+    def each(&block)
+      return self.to_enum(:each) unless block_given?
+      @data.each_along_dim(0, &block)
+    end
+
+    def each_index(&block)
+      self.each.with_index(&block)
+    end
+
+    # uniq
+    def factors
+      index = @data.sorted_indices
+      index.reduce([]){|memo, val| memo.push(@data[val]) if memo.last != @data[val]; memo}
+    end
+
+    def frequencies
+      index = @data.sorted_indices
+      index.reduce({}){|memo, val| memo[@data[val]] ||= 0; memo[@data[val]] += 1; memo}
+    end
+
+    def has_missing_data?
+      false
+    end
+
+    def is_valid?
+      true
+    end
+
+    def kurtosis(m=nil)
+      m ||= self.mean
+      fo=self.reduce(0){|a, x| a+((x-m)**4)}
+      fo.quo(self.length*sd(m)**4)-3
+    end
+
+    # alias_method :label, :labeling
+    # labeling(x) would be not implemented
+
+    def mean
+      @data.mean.first
+    end
+
+    def median
+      self.percentil(50)
+    end
+
+    def median_absolute_deviation
+      m = self.median
+      self.recode{|val| (val-m).abls}.median
+    end
+
+    def mode
+      self.frequencies.max
+    end
+
+    def ==(other)
+      @data==other
+    end
+
+    def n_valid
+      self.length
+    end
+
+    def percentil(percent)
+      index = @data.sorted_indices
+      pos = (self.length * percent)/100
+      if pos.to_i == pos
+        @data[index[pos.to_i]]
+      else
+        pos = (pos-0.5).to_i
+        (@data[index[pos]] + @data[index[pos+1]])/2
+      end
+    end
+
+    def product
+      @data.inject(1){|memo, val| memo*val}
+    end
+
+    def proportion(val=1)
+      self.frequencies[val]/self.n_valid
+    end
+
+    def proportion_confidence_interval_t
+      raise "NotImplementedError"
+    end
+
+    def proportion_confidence_interval_z
+      raise "NotImplementedError"
+    end
+
+    def proportions
+      len = self.n_valid
+      self.frequencies.reduce({}){|memo, arr| memo[arr[0]] = arr[1]/len}
+    end
+
+    def push(val)
+      self.expand(self.length+1)
+      self[self.length-1] = recode
+    end
+
+    def range
+      max - min
+    end
+
+    # ?
+    def ranked
+      sum = 0
+      r = self.frequencies.sort.reduce({}) do |memo, val|
+        memo[val[0]] = ((sum+1) + (sum+val[1]))/2
+        sum += val[1]
+        memo
+      end
+      Mikon::DArray.new(self.reduce{|val| r[val]})
+    end
+
+    def recode(&block)
+      Mikon::DArray.new(@data.map(&block))
+    end
+
+    def recode!(&block)
+      @data.map!(&block)
+    end
+
+    # report_building(b) would not be implemented
+    # sample_with_replacement
+    # sample_without_replacement
+
+    # set_valid_data
+
+    def skew(m=nil)
+      m ||= self.mean
+      th = self.reduce(0){|memo, val| memo + ((val - m)**3)}
+      th/((self.length)*self.sd(m)**3)
+    end
+
+    # split_by_separator_freq
+    # splitted
+
+    def standard_deviation_population(m=nil)
+      m ||= self.mean
+      Math.sqrt(self.variance_population(m))
+    end
+
+    def standard_deviation_sample(m=nil)
+      if !m.nil?
+        Math.sqrt(variance_sample(m))
+      else
+        @data.std.first
+      end
+    end
+
+    def standard_error
+      self.standard_deviation_sample/(Math.sqrt(self.length))
+    end
+
+    def sum_of_squared_deviation
+      self.reduce(0){|memo, val| val**2 + memo}
+    end
+
+    def sum_of_squares(m=nil)
+      m ||= self.mean
+      self.reduce(0){|memo, val| memo + (val-m)**2}
+    end
+
+    def sum
+      @data.sum.first
+    end
+
+    # today_values
+    # type=
+
+    # def variance_population
+    # def variance_proportion
+
+    def variance_sample(m=nil)
+      m ||= self.mean
+      self.sum_of_squares(m)/(self.length-1)
+    end
+
+    # def variance_total
+    # def vector_centered
+    # def vector_labeled
+    # def vector_percentil
+
+    def vector_standarized
+      raise "NotImplementedError"
+    end
+
+    alias_method :n, :size
+    alias_method :sd, :standard_deviation_sample
+    alias_method :sds, :standard_deviation_sample
+    alias_method :sdp, :standard_deviation_population
+    alias_method :se, :standard_error
+    alias_method :adp, :average_deviation_population
+    alias_method :mad, :median_absolute_deviation
+    alias_method :ss, :sum_of_squares
+    alias_method :flawed?, :has_missing_data?
+    alias_method :standarized, :vector_standarized
+    alias_method :variance, :variance_sample
+  end
+end