daru 0.0.2.3 → 0.0.3

data/lib/daru/dataframe_by_row.rb

@@ -0,0 +1,15 @@
+module Daru
+  class DataFrameByRow
+    def initialize data_frame
+      @data_frame = data_frame
+    end
+
+    def [](*names)
+      @data_frame[*names, :row]
+    end
+
+    def []=(name, vector)
+      @data_frame[name, :row] = vector
+    end
+  end
+end

data/lib/daru/dataframe_by_vector.rb

@@ -0,0 +1,15 @@
+module Daru
+  class DataFrameByVector
+    def initialize data_frame
+      @data_frame = data_frame
+    end
+
+    def [](*names)
+      @data_frame[*names, :vector]
+    end
+
+    def []=(name, vectors)
+      @data_frame[name, :vector] = vectors
+    end
+  end
+end

data/lib/daru/index.rb

@@ -0,0 +1,83 @@
+module Daru
+  class Index
+    include Enumerable
+
+    # needs to iterate over keys sorted by their values. Happens right now by 
+    # virtue of ordered Hashes (ruby).
+    def each(&block)
+      @relation_hash.each_key(&block)
+    end
+
+    attr_reader :relation_hash
+
+    attr_reader :size
+
+    attr_reader :index_class
+
+    def initialize index
+      @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)
+
+        @relation_hash[n] = idx 
+      end
+      @relation_hash.freeze
+
+      @size = @relation_hash.size
+
+      if index[0].is_a?(Integer)
+        @index_class = Integer
+      else
+        @index_class = Symbol
+      end
+    end
+
+    def ==(other)
+      return false if other.size != @size
+
+      @relation_hash.keys == other.to_a
+    end
+
+    def [](key)
+      @relation_hash[key]
+    end
+
+    def +(other)
+      if other.respond_to? :relation_hash #another index object
+        (@relation_hash.keys + other.relation_hash.keys).uniq.to_index
+      elsif other.is_a?(Symbol) or other.is_a?(Integer)
+        (@relation_hash.keys << other).uniq.to_index
+      else
+        (@relation_hash.keys + other).uniq.to_index
+      end
+    end
+
+    def to_a
+      @relation_hash.keys
+    end
+
+    def key(value)
+      @relation_hash.key value
+    end
+
+    def re_index new_index
+      new_index.to_index
+    end
+
+    def include? index
+      @relation_hash.has_key? index
+    end
+
+    def dup
+      Daru::Index.new @relation_hash.keys
+    end
+
+    def to_index
+      self
+    end
+  end
+end

data/lib/daru/io.rb

@@ -0,0 +1,30 @@
+module Daru
+  module IO
+    class << self
+      def from_csv path, opts={}
+        opts[:col_sep]           ||= ','
+        opts[:headers]           ||= true
+        opts[:converters]        ||= :numeric
+        opts[:header_converters] ||= :symbol
+
+        csv = CSV.open(path, 'r', opts)
+
+        yield csv if block_given?
+
+        first = true
+        df    = nil
+
+        csv.each_with_index do |row, index|
+          if first
+            df    = Daru::DataFrame.new({}, csv.headers)
+            first = false
+          end
+
+          df.row[index] = row.fields
+        end
+
+        df
+      end
+    end
+  end
+end

data/lib/daru/monkeys.rb

@@ -1,38 +1,46 @@
 class Array
-  def daru_vector name=nil
-    Daru::Vector.new self, name
+  def daru_vector name=nil, index=nil
+    Daru::Vector.new name, self, index
   end
 
   alias_method :dv, :daru_vector
+
+  def to_index
+    Daru::Index.new self
+  end
 end
 
 class Range
-  def daru_vector name=nil
-    Daru::Vector.new self, name
+  def daru_vector name=nil, index=nil
+    Daru::Vector.new name, self, index
   end
 
   alias_method :dv, :daru_vector
+
+  def to_index
+    Daru::Index.new self.to_a
+  end
 end
 
 class Hash
-  def daru_vector
-    Daru::Vector.new self.values[0], self.keys[0]
+  def daru_vector index=nil
+    Daru::Vector.new self.values[0], self.keys[0], index
   end
 
   alias_method :dv, :daru_vector
 end
 
 class NMatrix
-  def daru_vector name=nil
-    Daru::Vector.new self
+  def daru_vector name=nil, index=nil
+    Daru::Vector.new name, self, index
   end
 
   alias_method :dv, :daru_vector
 end
 
 class MDArray
-  def daru_vector name=nil
-    Daru::Vector.new self, name
+  def daru_vector name=nil, index=nil
+    Daru::Vector.new name, self, index
   end
 
   alias_method :dv, :daru_vector

data/lib/daru/vector.rb

@@ -6,96 +6,227 @@ module Daru
       @vector.each(&block)
     end
 
-    attr_accessor :name
-
-    attr_reader   :size
+    attr_reader :name
+    attr_reader :index
+    attr_reader :size
+
+    # Pass it name, source and index
+    def initialize *args
+      name   = args.shift
+      source = args.shift || []
+      index  = args.shift
+
+      set_name name
+
+      @vector = 
+      case source
+      when Array
+        source.dup
+      when Range, Matrix
+        source.to_a.dup
+      else # NMatrix or MDArray
+        source.dup
+      end
 
-    attr_reader   :vector
- 
-    def initialize source=[], name=nil
-      if source.is_a?(Hash)
-        initialize source.values[0], source.keys[0]
+      if index.nil?
+        @index = Daru::Index.new @vector.size  
+      else
+        @index = index.to_index
+      end
+      # TODO: Will need work for NMatrix/MDArray
+      if @index.size >= @vector.size
+        (@index.size - @vector.size).times { @vector << nil }
       else
-        @name = name || SecureRandom.uuid
+        raise IndexError, "Expected index size >= vector size"
+      end
+
+      set_size
+    end
 
-        @vector = 
-        case source
-        when Range, Matrix
-          source.to_a.flatten
+    def [](index, *indexes)
+      if indexes.empty?
+        if @index.include? index
+          @vector[@index[index]]
+        elsif index.is_a?(Numeric)
+          @vector[index]
         else
-          source
+          raise IndexError, "Specified index #{index} does not exist."
         end
+      else
+        indexes.unshift index
 
-        @size = @vector.size
+        Daru::Vector.new @name, indexes.map { |index| @vector[@index[index]] }, indexes
       end
     end
 
-    def [](index)
-      @vector[index]
+    def []=(index, value)
+      if @index.include? index
+        @vector[@index[index]] = value
+      else
+        @vector[index] = value
+      end
+
+      set_size
     end
 
-    def []=(index, value)
-      @vector[index] = value
+    # Two vectors are equal if the have the exact same index values corresponding
+    # with the exact same elements. Name is ignored.
+    def == other
+      @index == other.index and @size == other.size and
+      @index.all? do |index|
+        self[index] == other[index]
+      end
     end
 
-    def ==(other)
-      other.vector == @vector and other.name == @name and other.size == @size
+    def << element
+      concat element
     end
 
-    def <<(element)
-      @vector << element
+    def concat element, index=nil
+      raise IndexError, "Expected new unique index" if @index.include? index
+
+      if index.nil? and @index.index_class == Integer
+        @index = Daru::Index.new @size+1
+        index  = @size
+      else
+        begin
+          @index = @index.re_index(@index + index)
+        rescue Exception => e
+          raise e, "Expected valid index."
+        end
+      end
 
       @size += 1
-    end
 
-    def to_json
-      self.to_a.to_json
+      @vector[@index[index]] = element
     end
 
-    def to_a
-      @vector.to_a
+    def delete element
+      self.delete_at index_of(element)      
     end
 
-    def to_nmatrix
-      @vector.to_nm
+    def delete_at index
+      idx = named_index_for index
+
+      @vector.delete_at @index[idx]
+
+      if @index.index_class == Integer
+        @index = Daru::Index.new @size-1
+      else
+        @index = (@index.to_a - [idx]).to_index
+      end
+
+      set_size
     end
 
-    alias_method :to_nm, :to_nmatrix
+    def index_of element
+      @index.key @vector.index(element) #calling Array#index
+    end
 
-    def first lim=1
-      lim == 1 ? @vector.first : @vector.first(lim)
+    def to_hash
+      @index.inject({}) do |hsh, index|
+        hsh[index] = self[index]
+        hsh
+      end
     end
 
-    def delete index
-      @vector[index] = nil
-      @vector.compact!
-      @size -= 1
+    def to_json *args 
+      self.to_hash.to_json
     end
 
     def to_html threshold=15
-      html = '<table><tr><th>' + @name.to_s + '</th></tr>>'
+      name = @name || 'nil'
+
+      html = '<table>' + '<tr><th> </th><th>' + name.to_s + '</th></tr>'
 
-      @vector.to_a.each_with_index do |el,i|
-        next if threshold < i and i < @arr.length-1
-        content = i == threshold ? '...' : el.to_s
-        html.concat('<tr><td>' + content  + '</td></tr>')
+      @index.each_with_index do |index, num|
+        html += '<tr><td>' + index.to_s + '</td>' + '<td>' + self[index].to_s + '</td></tr>'
+    
+        if num > threshold
+          html += '<tr><td>...</td><td>...</td></tr>'
+          break
+        end
       end
 
       html += '</table>'
+
+      html
+    end
+
+    def to_s
+      to_html
+    end
+
+    def inspect spacing=10, threshold=15
+      longest = [@index.to_a.map(&:to_s).map(&:size).max, 
+                 @vector    .map(&:to_s).map(&:size).max].max
+
+      content   = ""
+      longest   = spacing if longest > spacing
+      name      = @name || 'nil'
+      formatter = "\n%#{longest}.#{longest}s %#{longest}.#{longest}s"
+
+      content += "\n#<" + self.class.to_s + ":" + self.object_id.to_s + " @name = " + name.to_s + " @size = " + size.to_s + " >"
+
+      content += sprintf formatter, "", name
+      @index.each_with_index do |index, num|
+        content += sprintf formatter, index.to_s, self[index]
+
+        if num > threshold
+          content += sprintf formatter, '...', '...'
+          break
+        end
+      end
+
+      content += "\n"
+
+      content
+    end
+
+    def compact!
+      # TODO: Compact and also take care of indexes
+      # @vector.compact!
+      # set_size
+    end
+
+    def rename new_name
+      @name = new_name.to_sym
     end
 
-    def dup
-      Daru::Vector.new @vector.dup, @name
+    def dup 
+      Daru::Vector.new @name, @vector.dup, @index.dup
     end
 
-    def daru_vector
+    def daru_vector *name
       self
     end
 
     alias_method :dv, :daru_vector
 
-    def compact!
-      @vector.compact!
+   private
+
+    def named_index_for index
+      if @index.include? index
+        index
+      elsif @index.key index
+        @index.key index
+      else
+        raise IndexError, "Specified index #{index} does not exist."
+      end
+    end
+
+    def set_size
+      @size = @vector.size
+    end
+
+    def set_name name
+      if name.is_a?(Numeric)
+        @name = name 
+      elsif name # anything but Numeric or nil
+        @name = name.to_sym
+      else
+        @name = nil
+      end
     end
   end
 end