mathpack 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 990d138b20708752c754e294a22627435a3a5ce9
-  data.tar.gz: dbb63f6b4cea510030e05c819cd2bac9a5c7376a
+  metadata.gz: 4ff99464e0f1a06b1ba3c2d3423096577a3649d1
+  data.tar.gz: e41163fd0942911d66072c0d1b579d83ba9cec75
 SHA512:
-  metadata.gz: 36318534efa67765b74962c5d6b102b7e0e4c4b2e2bbda35a795c443be5d6e7b09f6ec9be97f014ae7e8db88a6831ef710afb42714164ead92322b35f3c9433a
-  data.tar.gz: 38db3fd63908159911ef2ba99d8b6a0b899ae26010482104db5aa384f42f61f1176dcec6c59672fe664fb342f4f6817a5540a3d3289950cfaf4d382212194338
+  metadata.gz: 73f068a79ab03282563afd02416d48e1d54fb70b1f88d8286e0ac918215070ee8f3cc674cb731dc12878073b5fd4b0f1bce9ada7818a4271fb9748209c0c7880
+  data.tar.gz: 8287a6d59751b79d6e6ed2df1cebb1fcea04763618f104c838bd747e01c8e835fb657b47e815a246007e1988cf288c87c63690d4e3da6ff32657ee4149e4b75b

data/lib/mathpack/approximation.rb

@@ -1,5 +1,3 @@
-require 'mathpack'
-
 module Mathpack
   module Approximation
     def self.basic_fi(x, power)
@@ -57,12 +55,13 @@ module Mathpack
 
     def self.generate_nodes(params = {})
       nodes = []
-      x = params[:start]
+      i = 0
       loop do
-        nodes << x
-        x += params[:step]
-        break if x > params[:end]
+        nodes << params[:start] + i * params[:step]
+        i += 1
+        break if params[:start] + i * params[:step] > params[:end]
       end
+      nodes << params[:end] if nodes.last != params[:end]
       nodes
     end
 

data/lib/mathpack/version.rb

@@ -1,3 +1,3 @@
 module Mathpack
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/spec/approximation_spec.rb

@@ -9,30 +9,35 @@ describe 'Approximation' do
     let(:values) { Mathpack::Approximation.fill_f(nodes){ |val| val**2 } }
 
     it 'should generate nodes' do
-      expect(nodes.length).to eql(41)
-      expect(nodes.first).to eql(x_start)
-      expect(nodes.last).to eql(x_end)
+      expect(nodes.length).to eq(41)
+      expect(nodes.first).to eq(x_start)
+      expect(nodes.last).to eq(x_end)
+    end
+
+    it 'should generate correct nodes' do
+      nodes = Mathpack::Approximation.generate_nodes(start: 0, end: 1, step: 0.001)
+      expect(nodes.last).to eq(1.0)
     end
 
     it 'should fill function table' do
-      expect(values.length).to eql(nodes.length)
-      expect(values.last).to eql(nodes.last**2)
+      expect(values.length).to eq(nodes.length)
+      expect(values.last).to eq(nodes.last**2)
     end
 
     it 'should print polynoms' do
-      expect(Mathpack::Approximation.print_polynom([5])).to eql('5')
-      expect(Mathpack::Approximation.print_polynom([2, 3])).to eql('2*x + 3')
-      expect(Mathpack::Approximation.print_polynom([1, -1, 1])).to eql('x^2 - x + 1')
-      expect(Mathpack::Approximation.print_polynom([1, 3, 5])).to eql('x^2 + 3*x + 5')
-      expect(Mathpack::Approximation.print_polynom([1, -2, 3, -4])).to eql('x^3 - 2*x^2 + 3*x - 4')
-      expect(Mathpack::Approximation.print_polynom([1, 0, 1])).to eql('x^2 + 1')
+      expect(Mathpack::Approximation.print_polynom([5])).to eq('5')
+      expect(Mathpack::Approximation.print_polynom([2, 3])).to eq('2*x + 3')
+      expect(Mathpack::Approximation.print_polynom([1, -1, 1])).to eq('x^2 - x + 1')
+      expect(Mathpack::Approximation.print_polynom([1, 3, 5])).to eq('x^2 + 3*x + 5')
+      expect(Mathpack::Approximation.print_polynom([1, -2, 3, -4])).to eq('x^3 - 2*x^2 + 3*x - 4')
+      expect(Mathpack::Approximation.print_polynom([1, 0, 1])).to eq('x^2 + 1')
     end
 
     it 'should approximate by polynom' do
       coefficients = Mathpack::Approximation.approximate_by_polynom(x: nodes, f: values, polynom_power: 2)
-      expect(coefficients).to eql([1.0, 0.0, 0.0])
+      expect(coefficients).to eq([1.0, 0.0, 0.0])
       coefficients = Mathpack::Approximation.approximate_by_polynom(x: nodes, f: values, polynom_power: 0)
-      expect(coefficients).to eql([33.75])
+      expect(coefficients).to eq([33.75])
     end
   end
 end

data/spec/sle_spec.rb

@@ -9,7 +9,7 @@ describe 'SLE' do
     let(:vector_b) { Matrix.row_vector([15, 30, 15])  }
 
     it 'should give correct answer' do
-      expect(Mathpack::SLE.solve(matrix: a, f: b)).to eql([-1.0, 2.0, 4.0])
+      expect(Mathpack::SLE.solve(matrix: a, f: b)).to eq([-1.0, 2.0, 4.0])
     end
 
     it 'should raise error' do
@@ -17,7 +17,7 @@ describe 'SLE' do
     end
 
     it 'should return vector if matrix class is given' do
-      expect(Mathpack::SLE.solve(matrix: matrix_a, f: vector_b)).to eql(Matrix.row_vector [-1.0, 2.0, 4.0])
+      expect(Mathpack::SLE.solve(matrix: matrix_a, f: vector_b)).to eq(Matrix.row_vector [-1.0, 2.0, 4.0])
     end
   end
 end

data/spec/statistics_spec.rb

@@ -7,61 +7,61 @@ describe 'Statistics' do
     let(:stat) { Mathpack::Statistics.new(data) }
 
     it 'should calculate number of elements' do
-      expect(stat.number).to eql(10)
+      expect(stat.number).to eq(10)
     end
 
     it 'should calculate mean' do
-      expect(stat.mean).to eql(4.0)
+      expect(stat.mean).to eq(4.0)
     end
 
     it 'should calculate variance' do
-      expect(stat.variance).to eql(3.8)
+      expect(stat.variance).to eq(3.8)
     end
 
     it 'should calculate skewness' do
-      expect(stat.skewness).to eql(0.16199658190818222)
+      expect(stat.skewness).to eq(0.16199658190818222)
     end
 
     it 'should calculate kurtosis' do
-      expect(stat.kurtosis).to eql(1.925207756232687)
+      expect(stat.kurtosis).to eq(1.925207756232687)
     end
 
     it 'should calculate the minimal element' do
-      expect(stat.min).to eql(1)
+      expect(stat.min).to eq(1)
     end
 
     it 'should calculate the maximal element' do
-      expect(stat.max).to eql(7)
+      expect(stat.max).to eq(7)
     end
 
     it 'should calculate first raw moment equal to mean' do
-      expect(stat.raw_moment(1)).to eql(stat.mean)
+      expect(stat.raw_moment(1)).to eq(stat.mean)
     end
 
     it 'should calculate second central moment equal to variance' do
-      expect(stat.central_moment(2)).to eql(stat.variance)
+      expect(stat.central_moment(2)).to eq(stat.variance)
     end
 
     it 'should calculate raw moments' do
-      expect(stat.raw_moment(3)).to eql(110.8)
+      expect(stat.raw_moment(3)).to eq(110.8)
     end
 
     it 'should calculate central moments' do
-      expect(stat.central_moment(5)).to eql(18.0)
+      expect(stat.central_moment(5)).to eq(18.0)
     end
 
     it 'should calculate empirical cdf values in points' do
-      expect(stat.empirical_cdf(stat.min - 0.1)).to eql(0.0)
-      expect(stat.empirical_cdf(stat.max + 0.1)).to eql(1.0)
-      expect(stat.empirical_cdf(stat.mean)).to eql(0.4)
+      expect(stat.empirical_cdf(stat.min - 0.1)).to eq(0.0)
+      expect(stat.empirical_cdf(stat.max + 0.1)).to eq(1.0)
+      expect(stat.empirical_cdf(stat.mean)).to eq(0.4)
     end
 
     it 'should calculate empirical pdf values in points' do
-      expect(stat.empirical_pdf(stat.mean)).to eql(0.1882412842233359)
+      expect(stat.empirical_pdf(stat.mean)).to eq(0.1882412842233359)
     end
 
     it 'should find trend' do
-      expect(stat.trend(polynom_power: 2)).to eql('0.0075757575757576055*x^2 + 0.2681818181818179*x + 2.233333333333334')
+      expect(stat.trend(polynom_power: 2)).to eq('0.0075757575757576055*x^2 + 0.2681818181818179*x + 2.233333333333334')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mathpack
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - maxmilan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler