daru 0.0.3.1 → 0.0.4

data/spec/index_spec.rb

@@ -51,4 +51,12 @@ describe Daru::Index do
         :bob, :jimi, :richie].to_index)
     end
   end
+
+  context "#[]" do
+    it "works with ranges" do
+      id = Daru::Index.new [:one, :two, :three, :four, :five, :six, :seven]
+
+      expect(id[:two..:five]).to eq(Daru::Index.new([:two, :three, :four, :five]))
+    end
+  end
 end

data/spec/io/io_spec.rb

@@ -15,6 +15,7 @@ describe Daru::DataFrame do
         end
       end
 
+
       expect(df.vectors).to eq([:image_resolution, :true_transform, :mls].to_index)
       expect(df.vector[:image_resolution].first).to eq(6.55779)
       expect(df.vector[:true_transform].first[15]).to eq(1.0)

data/spec/math/statistics/vector_spec.rb

@@ -1,12 +1,153 @@
 require 'spec_helper.rb'
 
 describe Daru::Vector do
+  [NMatrix, Array].each do |dtype|
+    describe dtype do
+      before :each do
+        @dv = Daru::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2], dtype: dtype
+      end
 
-  context "#mean" do
+      context "#mean" do
+        it "calculates mean" do
+          expect(@dv.mean).to eq(282.2)
+        end
+      end
 
-  end
+      context "#sum_of_squares" do
+        it "calcs sum of squares" do
+
+        end
+      end
+
+      context "#standard_deviation_sample" do
+        it "calcs standard deviation sample" do
+
+        end
+      end
+
+      context "#variance_sample" do
+        it "calculates sample variance" do
+
+        end
+      end
+
+      context "#standard_deviation_population" do
+        it "calculates standard deviation population" do
+
+        end
+      end
+
+      context "#variance_population" do
+        it "calculates population variance" do
+          expect(@dv.variance_population).to eq(67606.95999999999)
+        end
+      end
+
+      context "#sum_of_squared_deviation" do
+        it "calculates sum of squared deviation" do
+          expect(@dv.sum_of_squared_deviation).to eq(676069.6)
+        end
+      end
+
+      context "#skew" do
+        it "calculates skewness" do
+          @dv.skew
+        end
+      end
+
+      context "#max" do
+        it "returns the max value" do
+          @dv.max
+        end
+      end
+
+      context "#min" do
+        it "returns the min value" do
+          @dv.min
+        end
+      end 
+
+      context "#sum" do
+        it "returns the sum" do
+          @dv.sum
+        end
+      end
+
+      context "#product" do
+        it "returns the product" do
+          @dv.product
+        end
+      end
+
+      context "#median" do
+        it "returns the median" do
+          @dv.median
+        end
+      end
+
+      context "#mode" do
+        it "returns the mode" do
+          @dv.mode
+        end
+      end
+
+      context "#kurtosis" do
+        it "calculates kurtosis" do
+          @dv.kurtosis
+        end
+      end
+
+      context "#percentile" do
+        it "calculates percentile" do
+          expect(@dv.percentile(50)).to eq(333.0)
+        end
+      end
+
+      context "#recode" do
+
+      end
+
+      context "#recode!" do
+
+      end
+
+      context "#frequencies" do
+        it "calculates frequencies" do
+          @dv.frequencies
+        end
+      end
+
+      context "#average_deviation_population" do
+        it "calculates average_deviation_population" do
+          @dv.average_deviation_population
+        end
+      end
+
+      context "#proportion" do
+
+      end
+
+      context "#proportions" do
+        it "calculates proportions" do
+          @dv.proportions
+        end
+      end
+
+      context "#ranked" do
+        it "curates by rank" do
+          @dv.ranked
+        end
+      end
+
+      context "#count" do
 
-  context "#median" do
+      end
 
+      context "#coefficient_of_variation" do
+        it "calculates coefficient_of_variation" do
+          @dv.coefficient_of_variation
+        end
+      end
+    end
   end
 end

data/spec/vector_spec.rb

@@ -1,155 +1,172 @@
 require 'spec_helper.rb'
 
 describe Daru::Vector do
-  context "#initialize" do
-    it "initializes from an Array" do
-      dv = Daru::Vector.new [1,2,3,4,5], name: :ravan, index: [:ek, :don, :teen, :char, :pach]
+  [Array, NMatrix].each do |dtype|
+    describe dtype do
+      context "#initialize" do
+        it "initializes from an Array" do
+          dv = Daru::Vector.new [1,2,3,4,5], name: :ravan, 
+            index: [:ek, :don, :teen, :char, :pach], dtype: dtype
 
-      expect(dv.name) .to eq(:ravan)
-      expect(dv.index).to eq(Daru::Index.new [:ek, :don, :teen, :char, :pach])
-    end
-
-    it "accepts Index object" do
-      idx = Daru::Index.new [:yoda, :anakin, :obi, :padme, :r2d2]
-
-      dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: idx
-
-      expect(dv.name) .to eq(:yoga)
-      expect(dv.index).to eq(idx)
-    end
-
-    it "raises error for improper Index" do
-      expect {
-        dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:i, :j, :k]
-      }.to raise_error
-
-      expect {
-        idx = Daru::Index.new [:i, :j, :k]
-        dv  = Daru::Vector.new [1,2,3,4,5], name: :yoda, index: idx 
-      }.to raise_error
-    end
-
-    it "initializes without specifying an index" do
-      dv = Daru::Vector.new [1,2,3,4,5], name: :vishnu
-
-      expect(dv.index).to eq(Daru::Index.new [0,1,2,3,4])
-    end
-
-    it "inserts nils for extra indices" do
-      dv = Daru::Vector.new [1,2,3], name: :yoga, index: [0,1,2,3,4]
-
-      expect(dv).to eq([1,2,3,nil,nil].dv(:yoga))
-    end
-  end
-
-  context "#[]" do
-    before :each do
-      @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:yoda, :anakin, :obi, :padme, :r2d2]
-    end
-
-    it "returns an element after passing an index" do
-      expect(@dv[:yoda]).to eq(1)
-    end
-
-    it "returns an element after passing a numeric index" , :focus => true do
-      expect(@dv[0]).to eq(1)
-    end
-
-    it "returns a vector with given indices for multiple indices" do
-      expect(@dv[:yoda, :anakin]).to eq(Daru::Vector.new([1,2], name: :yoda, 
-        index: [:yoda, :anakin]))
-    end
-  end
-
-  context "#[]=" do
-    before :each do
-      @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:yoda, :anakin, :obi, :padme, :r2d2]
-    end
-
-    it "assigns at the specified index" do
-      @dv[:yoda] = 666
-
-      expect(@dv[:yoda]).to eq(666)
-    end
-
-    it "assigns at the specified Integer index" do
-      @dv[0] = 666
-
-      expect(@dv[:yoda]).to eq(666)
-    end
-  end
-
-  context "#concat" do
-    before :each do
-      @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:warwick, :thompson, :jackson, :fender, :esp]
-    end
-
-    it "concatenates a new element at the end of vector with index" do
-      @dv.concat 6, :ibanez
-
-      expect(@dv.index)   .to eq(
-        [:warwick, :thompson, :jackson, :fender, :esp, :ibanez].to_index)
-      expect(@dv[:ibanez]).to eq(6)
-      expect(@dv[5])      .to eq(6)
-    end
-
-    it "concatenates without index if index is default numeric" do
-      vector = Daru::Vector.new [1,2,3,4,5], name: :nums
-
-      vector.concat 6
-
-      expect(vector.index).to eq([0,1,2,3,4,5].to_index)
-      expect(vector[5])   .to eq(6)
-    end
-
-    it "raises error if index not specified and non-numeric index" do
-      expect {
-        @dv.concat 6
-      }.to raise_error
-    end
-  end
-
-  context "#delete" do
-    it "deletes specified value in the vector" do
-      dv = Daru::Vector.new [1,2,3,4,5], name: :a
-
-      dv.delete 3
-
-      expect(dv).to eq(Daru::Vector.new [1,2,4,5], name: :a)
-    end
-  end
-
-  context "#delete_at" do
-    before :each do
-      @dv = Daru::Vector.new [1,2,3,4,5], name: :a, index: [:one, :two, :three, :four, :five]
-    end
-
-    it "deletes element of specified index" do
-      @dv.delete_at :one
-
-      expect(@dv).to eq(Daru::Vector.new [2,3,4,5], name: :a, index: [:two, :three, :four, :five])
-    end
-
-    it "deletes element of specified integer index" do
-      @dv.delete_at 2
-
-      expect(@dv).to eq(Daru::Vector.new [1,2,4,5], name: :a, index: [:one, :two, :four, :five])
-    end
-  end
-
-  context "#index_of" do
-    it "returns index of specified value" do
-      dv = Daru::Vector.new [1,2,3,4,5], name: :a, index: [:one, :two, :three, :four, :five]
-
-      expect(dv.index_of(1)).to eq(:one)
-    end
-  end
-
-  context "#to_hash" do
-    it "returns the vector as a hash" do
-      dv = Daru::Vector.new [1,2,3,4,5], name: :a, index: [:one, :two, :three, :four, :five]
-
-      expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+          expect(dv.name) .to eq(:ravan)
+          expect(dv.index).to eq(Daru::Index.new [:ek, :don, :teen, :char, :pach])
+        end
+
+        it "accepts Index object" do
+          idx = Daru::Index.new [:yoda, :anakin, :obi, :padme, :r2d2]
+
+          dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: idx, dtype: dtype
+
+          expect(dv.name) .to eq(:yoga)
+          expect(dv.index).to eq(idx)
+        end
+
+        it "raises error for improper Index" do
+          expect {
+            dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:i, :j, :k]
+          }.to raise_error
+
+          expect {
+            idx = Daru::Index.new [:i, :j, :k]
+            dv  = Daru::Vector.new [1,2,3,4,5], name: :yoda, index: idx, dtype: dtype 
+          }.to raise_error
+        end
+
+        it "initializes without specifying an index" do
+          dv = Daru::Vector.new [1,2,3,4,5], name: :vishnu, dtype: dtype
+
+          expect(dv.index).to eq(Daru::Index.new [0,1,2,3,4])
+        end
+
+        it "inserts nils for extra indices" do
+          dv = Daru::Vector.new [1,2,3], name: :yoga, index: [0,1,2,3,4], dtype: Array
+
+          expect(dv).to eq([1,2,3,nil,nil].dv(:yoga,nil, Array))
+        end
+      end
+
+      context "#[]" do
+        before :each do
+          @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
+            index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
+        end
+
+        it "returns an element after passing an index" do
+          expect(@dv[:yoda]).to eq(1)
+        end
+
+        it "returns an element after passing a numeric index" , :focus => true do
+          expect(@dv[0]).to eq(1)
+        end
+
+        it "returns a vector with given indices for multiple indices" do
+          expect(@dv[:yoda, :anakin]).to eq(Daru::Vector.new([1,2], name: :yoda, 
+            index: [:yoda, :anakin], dtype: dtype))
+        end
+      end
+
+      context "#[]=" do
+        before :each do
+          @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
+            index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
+        end
+
+        it "assigns at the specified index" do
+          @dv[:yoda] = 666
+
+          expect(@dv[:yoda]).to eq(666)
+        end
+
+        it "assigns at the specified Integer index" do
+          @dv[0] = 666
+
+          expect(@dv[:yoda]).to eq(666)
+        end
+      end
+
+      context "#concat" do
+        before :each do
+          @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
+            index: [:warwick, :thompson, :jackson, :fender, :esp], dtype: dtype
+        end
+
+        it "concatenates a new element at the end of vector with index" do
+          @dv.concat 6, :ibanez
+
+          expect(@dv.index)   .to eq(
+            [:warwick, :thompson, :jackson, :fender, :esp, :ibanez].to_index)
+          expect(@dv[:ibanez]).to eq(6)
+          expect(@dv[5])      .to eq(6)
+        end
+
+        it "concatenates without index if index is default numeric" do
+          vector = Daru::Vector.new [1,2,3,4,5], name: :nums, dtype: dtype
+
+          vector.concat 6
+
+          expect(vector.index).to eq([0,1,2,3,4,5].to_index)
+          expect(vector[5])   .to eq(6)
+        end
+
+        it "raises error if index not specified and non-numeric index" do
+          expect {
+            @dv.concat 6
+          }.to raise_error
+        end
+      end
+
+      context "#delete" do
+        it "deletes specified value in the vector" do
+          dv = Daru::Vector.new [1,2,3,4,5], name: :a, dtype: dtype
+
+          dv.delete 3
+
+          expect(dv).to eq(Daru::Vector.new [1,2,4,5], name: :a)
+        end
+      end
+
+      context "#delete_at" do
+        before :each do
+          @dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+            index: [:one, :two, :three, :four, :five], dtype: dtype
+        end
+
+        it "deletes element of specified index" do
+          @dv.delete_at :one
+
+          expect(@dv).to eq(Daru::Vector.new [2,3,4,5], name: :a, 
+            index: [:two, :three, :four, :five]), dtype: dtype
+        end
+
+        it "deletes element of specified integer index" do
+          @dv.delete_at 2
+
+          expect(@dv).to eq(Daru::Vector.new [1,2,4,5], name: :a, 
+            index: [:one, :two, :four, :five]), dtype: dtype
+        end
+      end
+
+      context "#index_of" do
+        it "returns index of specified value" do
+          dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+            index: [:one, :two, :three, :four, :five], dtype: dtype
+
+          expect(dv.index_of(1)).to eq(:one)
+        end
+      end
+
+      context "#to_hash" do
+        it "returns the vector as a hash" do
+          dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+            index: [:one, :two, :three, :four, :five], dtype: dtype
+
+          expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+        end
+      end
+
+      context "#uniq" do
+        # TODO
+      end
     end
   end
 end if mri?