mathpack 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 218d151cc62bb32f4f7080413b396d4d11f585ee
-  data.tar.gz: 8929b3f9775a341f3f491f1eb26bad71e490be51
+  metadata.gz: a8ce50434e6550fb905aa1cb215106fc208af310
+  data.tar.gz: 2bce06f9c4b43424bf26923d0ecf7c91789253d3
 SHA512:
-  metadata.gz: c45dcf42f3b70354c4a536aa5a053b5c1390664cd857d463d1ba1175277a01647772465861c7d3ec0d805229e622eac0b0288be24899968e9c717cd38f80fc36
-  data.tar.gz: 40d736560eb81d34c25c1dc985cdda85d838b8bc24c810469bed7ae6b6f562e5c7ff54f28de72c95a9021c13d8a6aeff2444f18963f2acde0026f8c216d598b8
+  metadata.gz: 8568cd24de9e9404a584e7f2723c62f604cfd5a9e8235f393f9f6438770b865dd0e569d8ce57d736f567b76c94edc7c1182efd484c17cc178bd6fdf01f2fcdc0
+  data.tar.gz: 5eb2691333cc2af964d925a4f7c3c6c75598c08c6229b6d321a6011e9003e7ceb89e463c13d99e47a7af149f2e4fbb44cf10bcb83ec4c9fe3ad05fa06dee9eff

data/README.md

@@ -17,15 +17,17 @@ And then execute:
 Or install it yourself as:
 
     $ gem install mathpack
+
 ## Information
 `Mathpack` includes following modules:
 - **SLE**. Solves system of linear equations
 - **Statistics**. Provides methods to analyze data samples
 - **Functions**. Collects mathematical functions
 - **Approximation**. Allows to approximate table and analytical functions by polynom
-- **Equation**. Solves unlinear mathematical equations
+- **NonlinearEquations**. Solves unlinear mathematical equations
 - **Integration**. Integrates functions
 - **IO**. Prints data
+- **Functional**. Lambda functions
 
 ## Statistics
 `Statistics` class have following methods
@@ -51,10 +53,10 @@ returns the **nth** central moment of series
 empirical distribution function value in **x**
 #### empirical_pdf(x)
 returns empirical probability density function value in **x**
-#### print_empirical_cdf_to_csv(filename)
-allows to print empirical_cdf table function to **filename.csv**
-#### print_empirical_pdf_to_csv(filename)
-allows to print empirical_pdf  table function to **filename.csv**
+#### print_empirical_cdf(filename)
+allows to print empirical_cdf table function to **filename**
+#### print_empirical_pdf(filename)
+allows to print empirical_pdf  table function to **filename**
 #### trend
 returns trend polynom coefficients
 
@@ -72,8 +74,8 @@ stat.raw_moment(3) #=> 87.5
 stat.central_moment(4) #=> 22.0625
 stat.empirical_cdf(5.5) #=> 0.75
 stat.empirical_pdf(3) #=> 0.07639393483317147
-stat.print_empirical_cdf_to_csv('cdf') #=> nil
-stat.print_empirical_pdf_to_csv('pdf') #=> nil
+stat.print_empirical_cdf('cdf.csv') #=> nil
+stat.print_empirical_pdf('pdf.csv') #=> nil
 stat.trend(polynom_power: 1) #=> 1.7999999999999996*x - 0.9999999999999987
 ```
 
@@ -90,11 +92,11 @@ stat.trend(polynom_power: 1) #=> 1.7999999999999996*x - 0.9999999999999987
 #### dawson_minus(x)
 ![equation](http://latex.codecogs.com/gif.latex?D_%7B-%7D%28x%29%20%3D%20e%5E%7Bx%5E%7B2%7D%7D%5Cint_%7B0%7D%5E%7Bx%7De%5E%7B-t%5E%7B2%7D%7Ddt)
 
-## Equation
+## NonlinearEquations
 #### solve(params = {})
 returns solution of nonlinear equation. 
 ##### Parameters
-- *start* - point to start root search
+- *start* - point to start iteration process
 - *eps* - calculations accuraccy
 
 ### Usage
@@ -108,14 +110,43 @@ You need to complete the following steps:
 
 Then to solve equation you should call 
 ```ruby
-Mathpack::Equation.solve(start: 0, eps: 0.00001){|x| x**2 - Math.sin(x+1)})
+Mathpack::NonlinearEquations.solve(start: 0, eps: 0.00001){|x| x**2 - Math.sin(x+1)})
 ```
 Here is some other examples of **solve** usage
 ```ruby
-Mathpack::Equation.solve(start: 0, eps: 0.00001){|x| x**2 - Math.sin(x+1)})
-Mathpack::Equation.solve(start: 0.01, eps: 0.00001){|x| 1/x - Math.log(x)})
-Mathpack::Equation.solve(start: 0.01, eps: 0.00001){|x| x**2 - 2*x + 1})
-Mathpack::Equation.solve(start: 0.01, eps: 0.00001){|x| Math.exp(x-2) - Math.sin(x)})
+Mathpack::NonlinearEquations.solve(start: 0, eps: 0.00001){|x| x**2 - Math.sin(x+1)})
+Mathpack::NonlinearEquations.solve(start: 0.01, eps: 0.00001){|x| 1/x - Math.log(x)})
+Mathpack::NonlinearEquations.solve(start: 0.01, eps: 0.00001){|x| x**2 - 2*x + 1})
+Mathpack::NonlinearEquations.solve(start: 0.01, eps: 0.00001){|x| Math.exp(x-2) - Math.sin(x)})
+```
+#### solve_system(params = {})
+returns solution of system of nonlinear equations by *Newton method*
+##### Parameters
+- *start* - vector to start iteration process
+- *eps* - calculations accuraccy
+- *f* - vector of right part lambdas
+- *w_matrix* - matrix *W* in Newton method
+
+### Usage
+If you have system of equations ![equation](http://latex.codecogs.com/gif.latex?f_%7Bi%7D%28x%29%20%3D%200%2C%20i%20%3D%200%2C%201%2C%20...%2C%20N-1)
+
+![equation](http://latex.codecogs.com/gif.latex?f%28x%29%20%3D%20%5Cbegin%7Bpmatrix%7D%20f_%7B0%7D%28x%29%5C%5C%20%5Ccdots%5C%5C%20f_%7BN-1%7D%28x%29%20%5Cend%7Bpmatrix%7D)
+
+![equation](http://latex.codecogs.com/gif.latex?W%28x%29%20%3D%20%5Cbegin%7Bpmatrix%7D%20%5Cfrac%7B%5Cpartial%20f_%7B0%7D%28x%29%7D%7B%5Cpartial%20x_%7B0%7D%7D%26%5Ccdots%26%5Cfrac%7B%5Cpartial%20f_%7B0%7D%28x%29%7D%7B%5Cpartial%20x_%7BN-1%7D%7D%5C%5C%20%5Ccdots%26%5Cddots%20%26%5Ccdots%20%5C%5C%20%5Cfrac%7B%5Cpartial%20f_%7BN-1%7D%28x%29%7D%7B%5Cpartial%20x_%7B0%7D%7D%26%5Ccdots%26%20%5Cfrac%7B%5Cpartial%20f_%7BN-1%7D%28x%29%7D%7B%5Cpartial%20x_%7BN-1%7D%7D%5C%20%5Cend%7Bpmatrix%7D)
+
+For example, if you have system
+
+![equation](http://latex.codecogs.com/gif.latex?%5Cleft%5C%7B%5Cbegin%7Bmatrix%7D%20x_%7B1%7D%20+%20x_%7B2%7D%20-%203%20%3D%200%5C%5C%20%7Bx_%7B1%7D%7D%5E%7B2%7D%20+%20%7Bx_%7B2%7D%7D%5E2%20-%209%20%3D%200%20%5Cend%7Bmatrix%7D%5Cright.)
+
+W matrix and f vector is equal
+
+![equation](http://latex.codecogs.com/gif.latex?W%28x%29%20%3D%20%5Cbigl%28%5Cbegin%7Bsmallmatrix%7D%201%20%26%201%5C%5C%202x_%7B1%7D%262x_%7B2%7D%20%5Cend%7Bsmallmatrix%7D%5Cbigr%29)
+
+![equation](http://latex.codecogs.com/gif.latex?f%28x%29%20%3D%20%5Cbigl%28%5Cbegin%7Bsmallmatrix%7D%20x_%7B1%7D%20+%20x_%7B2%7D%20-%203%5C%5C%20%7Bx_%7B1%7D%7D%5E%7B2%7D%20+%20%7Bx_%7B2%7D%7D%5E%7B2%7D%20-%209%20%5Cend%7Bsmallmatrix%7D%5Cbigr%29)
+```ruby
+f = -> x, y { [x + y - 3.0, x**2 + y**2 - 9.0] }
+w = -> x, y { [[1, 1], [2 * x, 2 * y]] }
+Mathpack::NonlinearEquations.solve_system(start: [1, 5], eps: 1e-4, f: f, w_matrix: w) #=> [-1.829420851037002e-12, 3.0000000000018296]
 ```
 
 ## SLE
@@ -213,19 +244,24 @@ Mathpack::Integration.integrate(from: -Float::INFINITY, to: Float::INFINITY){ |x
 ## IO
 
 #### print_table_function(params = {})
-writes table function values to *.csv* file
+writes table function values to file
 ##### Parameters
 - *filename* - name of output file
 - *x* - arguements array
 - *y* - function values array
 - *labels* - hash of labels names for *x* and *y* column
 
+#### read_table_function(filename)
+returns table function values hash, written to **filename**
+
 ### Usage
 
 If you have table function, represented by argument array and function values array, you should use
-**print_table_function**, that prints your data to **filename.csv** file.
+**print_table_function**, that prints your data to **filename** file.
+If you have table function, written to **filename** file, you should use **read_table_function**, that 
 ```ruby
 Mathpack::IO.print_table_function(filename: 'table.csv', x: [1, 2, 3], y: [2, 4, 6], labels: { x: 'x', y: 'f(x)'})
+Mathpack::IO.read_table_function('table.csv') #=> { x: [1, 2, 3], y: [2, 4, 6] }
 ```
 
 ## Contributing

data/lib/mathpack.rb

@@ -1,8 +1,9 @@
 require 'mathpack/version'
 require 'mathpack/statistics'
-require 'mathpack/equation'
+require 'mathpack/nonlinear_equations'
 require 'mathpack/sle'
 require 'mathpack/approximation'
 require 'mathpack/integration'
 require 'mathpack/io'
 require 'mathpack/functions'
+require 'mathpack/functional'

data/lib/mathpack/functional.rb

@@ -0,0 +1,46 @@
+module Mathpack
+  module Functional
+    @@minus = -> f,g { -> x { f.(x) - g.(x) } }
+    @@div   = -> f,g { -> x { f.(x) / g.(x) } }
+    @@mult  = -> f,g { -> x { f.(x) * g.(x) } }
+    @@norm  = -> f   { -> x { f.(x).abs } }
+    @@const = -> const { -> x { const} }
+
+    @@plus_eps = -> eps { -> f { -> x { f.(x + eps) } } }
+    @@min_eps  = -> eps { -> f { -> x { f.(x - eps) } } }
+
+    @@inf = -> f,g { -> x { f.(x) < g.(x) } }
+
+    @@lim = -> f,eps,prec {
+      -> x {
+        @@inf.(@@norm.(@@minus.(@@plus_eps.(eps/2.0).(f), @@plus_eps.(eps).(f))) , @@const.(prec) ).(x) ? @@plus_eps.(eps).(f).(x) : @@lim.(f,eps/2.0,prec).(x)
+      }
+    }
+
+    @@derivative_sheme = -> f {
+      -> x {
+        -> eps {
+          @@div.( @@minus.(@@plus_eps.(eps).(f), @@min_eps.(eps).(f) ), @@mult.(@@const.(2), @@const.(eps))).(x)
+        }
+      }
+    }
+
+    @@derivate = -> f{
+      -> x {
+        @@lim.(@@derivative_sheme.(f).(x),1, 1e-16).(0)
+      }
+    }
+
+    @@n_times = -> n,f {
+      n == 1 ? f : -> x { f.(@@n_times.(n - 1,f).(x))}
+    }
+
+    @@nth_derivator = -> n {
+      @@n_times.(n,@@derivate)
+    }
+
+    def self.derivative(n, &f)
+      @@nth_derivator.(n).(f)
+    end
+  end
+end

data/lib/mathpack/functions.rb

@@ -19,5 +19,9 @@ module Mathpack
     def self.dawson_minus(x)
       Math.exp(x**2) * Mathpack::Integration.integrate(from: 0.0, to: x) { |x| Math.exp(-x**2) }
     end
+
+    def self.heaviside(x)
+      x <= 0 ? 0 : 1
+    end
   end
 end

data/lib/mathpack/integration.rb

@@ -2,6 +2,7 @@ module Mathpack
   module Integration
     STEP = 0.0078125
     INTEGRATION_LIMIT = 1e2
+
     def self.integrate(params = {}, &f)
       if params[:from] == -Float::INFINITY && params[:to] == Float::INFINITY
         result = solve_oi(-INTEGRATION_LIMIT, INTEGRATION_LIMIT, &f)

data/lib/mathpack/io.rb

@@ -7,9 +7,10 @@ module Mathpack
     @@numbers = %w{0 1 2 3 4 5 6 7 8 9}
     @@math_constants = { 'pi' => 'Math::PI' }
     @@math_functions = { 'ln(' => 'Math.log(', 'e**(' => 'Math.exp(', 'arctg(' => 'Math.atan(', 'arcsin(' => 'Math.asin(', 'arccos(' => 'Math.acos(', 'sin(' => 'Math.sin(', 'cos(' => 'Math.cos(', 'tg(' => 'Math.tan(', 'lg(' => 'Math.log10(' }
+
     def self.print_table_function(params = {})
       fail 'Arrays length dismatch' if params[:x].length != params[:y].length
-      File.open(params[:filename] + '.csv'|| 'table_function.csv', 'w+') do |file|
+      File.open(params[:filename]|| 'table_function.csv', 'w+') do |file|
         file.write("#{params[:labels][:x]};#{params[:labels][:y]}\n") if params[:labels] && params[:labels][:x] && params[:labels][:y]
         params[:x].each_index do |i|
           file.write("#{params[:x][i]};#{params[:y][i]}\n")
@@ -20,7 +21,7 @@ module Mathpack
     def self.read_table_function(filename)
       x = []
       y = []
-      data = File.read(filename + '.csv')
+      data = File.read(filename)
       rows = data.split("\n")
       rows.delete!(0) unless rows[0].split(';')[0].to_f
       rows.each do |row|
@@ -95,5 +96,16 @@ module Mathpack
       calculate = -> str { ->x { eval str.gsub('var', x.to_s) } }
       calculate.(valid_function)
     end
+
+    def self.count_diff(first_array, second_array)
+      if first_array.length == second_array.length
+        diff = Array.new(first_array.length){ |i| (first_array[i] - second_array[i]).abs }
+      elsif first_array.length == second_array.length * 2 - 1
+        diff = Array.new(second_array.length) { |i| (first_array[2 * i] - second_array[i]).abs }
+      else
+        fail 'Arrays length mismatch'
+      end
+      diff.max
+    end
   end
 end

data/lib/mathpack/nonlinear_equations.rb

@@ -0,0 +1,39 @@
+module Mathpack
+  module NonlinearEquations
+    def self.solve(params = {}, &function)
+      xk1 = params[:start]
+      loop do
+        xk = xk1
+        xk1 = xk - function.call(xk) / derivative(xk, &function)
+        break if (xk1 - xk).abs < params[:eps]
+      end
+      xk1
+    end
+
+    def self.solve_system(params = {})
+      xk1 = params[:start].dup
+      loop do
+        xk = xk1.dup
+        w_xk = params[:w_matrix].call(*xk, *params[:additional_params])
+        f = params[:f].call(*xk, *params[:additional_params])
+        delta = Mathpack::SLE.solve(matrix: w_xk, f: invert(f))
+        xk1 = plus(xk, delta)
+        break if Mathpack::IO.count_diff(xk1, xk) <= params[:eps]
+      end
+      xk1
+    end
+
+    def self.invert(vector)
+      vector.map{ |element| -element }
+    end
+
+    def self.plus(first_array, second_array)
+      Array.new(first_array.length) { |i| first_array[i] + second_array[i] }
+    end
+
+    def self.derivative(xk, &function)
+      eps = 1e-5
+      (function.call(xk + eps) - function.call(xk - eps)) / (2 * eps)
+    end
+  end
+end

data/lib/mathpack/statistics.rb

@@ -52,11 +52,11 @@ module Mathpack
 
     def empirical_cdf(x)
       result = 0.0
-      @series.each { |val| result += heaviside(x - val) }
+      @series.each { |val| result += Mathpack::Functions.heaviside(x - val) }
       result / number
     end
 
-    def print_empirical_cdf_to_csv(filename)
+    def print_empirical_cdf(filename)
       step = 0.5 * (max - min) / number
       nodes = Mathpack::Approximation.generate_nodes(from: min - step, to: max + step, step: step)
       values = nodes.map { |x| empirical_cdf(x) }
@@ -66,11 +66,11 @@ module Mathpack
     def empirical_pdf(x)
       h = variance**0.5 * number**(-1.0 / 6)
       result = 0.0
-      @series.each { |val| result += (heaviside(x - val + h) - heaviside(x - val - h)) / (2 * h) }
+      @series.each { |val| result += (Mathpack::Functions.heaviside(x - val + h) - Mathpack::Functions.heaviside(x - val - h)) / (2 * h) }
       result / number
     end
 
-    def print_empirical_pdf_to_csv(filename)
+    def print_empirical_pdf(filename)
       step = 0.5 * (max - min) / number
       nodes = Mathpack::Approximation.generate_nodes(from: min - 10 * step, to: max + 10 * step, step: step)
       values = nodes.map { |x| empirical_pdf(x) }
@@ -85,10 +85,6 @@ module Mathpack
 
     private
 
-    def heaviside(x)
-      x <= 0 ? 0 : 1
-    end
-
     def parse_series(series)
       data_set = []
       frequency = []

data/lib/mathpack/version.rb

@@ -1,3 +1,3 @@
 module Mathpack
-  VERSION = '0.4.4'
+  VERSION = '0.4.5'
 end

data/spec/approximation_spec.rb

@@ -1,43 +1,51 @@
 describe 'Approximation' do
   require 'mathpack/approximation'
 
-  context '#mnk' do
+  context 'mnk' do
     let(:x_start) { 0.0 }
     let(:x_end) { 10.0 }
     let(:step) { 0.25 }
     let(:nodes) { Mathpack::Approximation.generate_nodes(from: x_start, to: x_end, step: step) }
     let(:values) { Mathpack::Approximation.fill_f(nodes){ |val| val**2 } }
 
-    it 'should generate nodes' do
-      expect(nodes.length).to eq(41)
-      expect(nodes.first).to eq(x_start)
-      expect(nodes.last).to eq(x_end)
-    end
+    describe '#generate_nodes' do
+      it 'generates nodes' do
+        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(from: 0, to: 1, step: 0.001)
-      expect(nodes.last).to eq(1.0)
+      it 'generates last node equal to right border of interval' do
+        nodes = Mathpack::Approximation.generate_nodes(from: 0, to: 1, step: 0.001)
+        expect(nodes.last).to eq(1.0)
+      end
     end
 
-    it 'should fill function table' do
-      expect(values.length).to eq(nodes.length)
-      expect(values.last).to eq(nodes.last**2)
+    describe '#fill_f' do
+      it 'fills function values in table' do
+        expect(values.length).to eq(nodes.length)
+        expect(values.last).to eq(nodes.last**2)
+      end
     end
 
-    it 'should print polynoms' do
-      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')
+    describe '#print_polynoms' do
+      it 'prints formatted polynoms' do
+        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
     end
 
-    it 'should approximate by polynom' do
-      coefficients = Mathpack::Approximation.approximate_by_polynom(x: nodes, f: values, polynom_power: 2)
-      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 eq([33.75])
+    describe '#approximate_by_polynom' do
+      it 'approximates function by polynom of some power' do
+        coefficients = Mathpack::Approximation.approximate_by_polynom(x: nodes, f: values, polynom_power: 2)
+        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 eq([33.75])
+      end
     end
   end
 end

data/spec/functional_spec.rb

@@ -0,0 +1,9 @@
+describe 'Functional' do
+  require 'mathpack/functional'
+
+  describe '#derivative' do
+    it 'calculates nth derivative' do
+      expect(Mathpack::Functional.derivative(2) { |x| x**3 }.(1)).to eq(6.0)
+    end
+  end
+end

data/spec/functions_spec.rb

@@ -2,7 +2,7 @@ describe 'Functions' do
   require 'mathpack/functions'
 
   describe '#gamma' do
-    it 'should calculate gamma function' do
+    it 'calculates gamma function' do
       expect(Mathpack::Functions.gamma(1.5)).to be_between(0.886225, 0.886229)
       expect(Mathpack::Functions.gamma(1.8)).to be_between(0.9313835, 0.9313844)
       expect(Mathpack::Functions.gamma(5.8)).to be_between(85.62165, 85.62174)
@@ -12,7 +12,7 @@ describe 'Functions' do
   end
 
   describe '#erf' do
-    it 'should calculate erf function' do
+    it 'calculates erf function' do
       expect((Mathpack::Functions.erf(0.0) - 0.5).abs < 1e-7).to eq(true)
       expect((Mathpack::Functions.erf(1.73) - 0.9582).abs < 1e-4).to eq(true)
       expect((Mathpack::Functions.erf(3.49) - 0.9998).abs < 1e-4).to eq(true)
@@ -20,20 +20,20 @@ describe 'Functions' do
   end
 
   describe '#beta' do
-    it 'should calculate beta function' do
+    it 'calculates beta function' do
       expect(Mathpack::Functions.beta(3.5, 2.2)).to be_between(0.0504866, 0.05048665)
     end
   end
 
   describe '#dawson_plus' do
-    it 'should calculate dawson_plus integral' do
+    it 'calculates dawson_plus integral' do
       expect(Mathpack::Functions.dawson_plus(0.924138873)).to be_between(0.5410442, 0.54104425)
       expect(Mathpack::Functions.dawson_plus(1.5019752683)).to be_between(0.427686616, 0.4276866164)
     end
   end
 
   describe '#dawson_minus' do
-    it 'should calculate dawson_minus integral' do
+    it 'calculates dawson_minus integral' do
       expect(Mathpack::Functions.dawson_minus(0.924138873) + Mathpack::Functions.dawson_minus(-0.924138873) < 1e-5).to eq(true)
     end
   end

data/spec/integration_spec.rb

@@ -1,7 +1,7 @@
 describe 'Integration' do
   require 'mathpack/integration'
 
-  context '#a-b integrals' do
+  context 'a-b integrals' do
     it 'should integrate e^(-x^2)' do
       expect(Mathpack::Integration.integrate(from: 0, to: 10){ |x| Math.exp(-x**2) }).to be_between(0.8862269254525, 0.8862269254534)
     end
@@ -20,7 +20,7 @@ describe 'Integration' do
     end
   end
 
-  context '#ni-1 integrals' do
+  context 'ni-1 integrals' do
     it 'should integrate e^(-x)/(x+1)' do
       expect(Mathpack::Integration.integrate(from: 0, to: Float::INFINITY){ |x| Math.exp(-x) / (x + 1) }).to be_between(0.596346, 0.596348)
     end
@@ -34,7 +34,7 @@ describe 'Integration' do
     end
   end
 
-  context '#ni-2 integrals' do
+  context 'ni-2 integrals' do
     it 'should integrate e^(-x^2)*cos(x)' do
       expect(Mathpack::Integration.integrate(from: -Float::INFINITY, to: Float::INFINITY){ |x| Math.exp(-x**2) * Math.cos(x) }).to be_between(1.3803, 1.3804)
     end

data/spec/nonlinear_equations_spec.rb

@@ -0,0 +1,23 @@
+describe 'Equation' do
+  require 'mathpack/nonlinear_equations'
+
+  describe '#solve' do
+    let(:eps) { 0.00001 }
+
+    it 'solves nonlinear equations correctly' do
+      expect(Mathpack::NonlinearEquations.solve(start: 0, eps: eps) { |x| x**2 - Math.sin(x + 1) }).to be_between(-0.613763 - eps, -0.613763 + eps)
+      expect(Mathpack::NonlinearEquations.solve(start: 0.01, eps: eps) { |x| 1 / x - Math.log(x) }).to be_between(1.76322 - eps, 1.76322 + eps)
+      expect(Mathpack::NonlinearEquations.solve(start: 0.01, eps: eps) { |x| x**2 - 2 * x + 1 }).to be_between(1.0 - eps, 1.0 + eps)
+      expect(Mathpack::NonlinearEquations.solve(start: 0.01, eps: eps) { |x| Math.exp(x - 2) - Math.sin(x) }).to be_between(0.159396 - eps, 0.159396 + eps)
+    end
+  end
+
+  describe '#solve_system' do
+    it 'solves system of nonlinear equations correctly' do
+      f = -> x, y { [x + y - 3.0, x**2 + y**2 - 9.0] }
+      w = -> x, y { [[1, 1], [2 * x, 2 * y]] }
+      solution = Mathpack::NonlinearEquations.solve_system(start: [1, 5], eps: 1e-4, f: f, w_matrix: w)
+      expect(Mathpack::IO.count_diff(solution, [0, 3]) <= 1e-4).to eq(true)
+    end
+  end
+end

data/spec/sle_spec.rb

@@ -1,22 +1,22 @@
 describe 'SLE' do
   require 'mathpack/sle'
 
-  context '#solve systems of linear equations' do
+  describe '#solve' do
     let(:a) { [[1, 2, 3], [4, 5, 6], [3, 5, 2]] }
     let(:unsolved) { [[1, 2, 3], [1, 2, 3], [3, 5, 2]] }
     let(:b) { [15, 30, 15] }
     let(:matrix_a) { Matrix[[1, 2, 3], [4, 5, 6], [3, 5, 2]] }
     let(:vector_b) { Matrix.row_vector([15, 30, 15])  }
 
-    it 'should give correct answer' do
+    it 'solves SLE correctly' do
       expect(Mathpack::SLE.solve(matrix: a, f: b)).to eq([-1.0, 2.0, 4.0])
     end
 
-    it 'should raise error when matrix is singular' do
+    it 'raises error when matrix is singular' do
       expect { Mathpack::SLE.solve(matrix: unsolved, f: b) }.to raise_error
     end
 
-    it 'should raise error when matrix has incorrect size' do
+    it 'raises error when matrix has incorrect size' do
       b << 1
       expect { Mathpack::SLE.solve(matrix: a, f: b) }.to raise_error
       b.pop
@@ -24,7 +24,7 @@ describe 'SLE' do
       expect { Mathpack::SLE.solve(matrix: a, f: b) }.to raise_error
     end
 
-    it 'should return vector if matrix class is given' do
+    it 'returns vector if matrix class is given' do
       expect(Mathpack::SLE.solve(matrix: matrix_a, f: vector_b)).to eq(Matrix.row_vector [-1.0, 2.0, 4.0])
     end
 

data/spec/statistics_spec.rb

@@ -1,8 +1,7 @@
 describe 'Statistics' do
   require 'mathpack/statistics'
 
-  describe '#calculate statistics functions' do
-
+  context 'calculate statistic parameters' do
     let(:data) do
       array = []
       array << [0]*50
@@ -14,62 +13,86 @@ describe 'Statistics' do
     end
     let(:stat) { Mathpack::Statistics.new(data) }
 
-    it 'should calculate number of elements' do
-      expect(stat.number).to eq(100)
+    describe '#number' do
+      it 'calculates number of elements' do
+        expect(stat.number).to eq(100)
+      end
     end
 
-    it 'should calculate mean' do
-      expect(stat.mean).to eq(0.71)
+    describe '#mean' do
+      it 'calculates mean' do
+        expect(stat.mean).to eq(0.71)
+      end
     end
 
-    it 'should calculate variance' do
-      expect(stat.variance).to eq(0.7659)
+    describe '#varince' do
+      it 'calculates variance' do
+        expect(stat.variance).to eq(0.7659)
+      end
     end
 
-    it 'should calculate skewness' do
-      expect(stat.skewness).to eq(1.3139557526940238)
+    describe '#skewness' do
+      it 'calculates skewness' do
+        expect(stat.skewness).to eq(1.3139557526940238)
+      end
     end
 
-    it 'should calculate kurtosis' do
-      expect(stat.kurtosis).to eq(1.5654257435282322)
+    describe '#kurtosis' do
+      it 'calculates kurtosis' do
+        expect(stat.kurtosis).to eq(1.5654257435282322)
+      end
     end
 
-    it 'should calculate the minimal element' do
-      expect(stat.min).to eq(0)
+    describe '#min' do
+      it 'finds the minimal element' do
+        expect(stat.min).to eq(0)
+      end
     end
 
-    it 'should calculate the maximal element' do
-      expect(stat.max).to eq(4)
+    describe '#max' do
+      it 'finds the maximal element' do
+        expect(stat.max).to eq(4)
+      end
     end
 
-    it 'should calculate first raw moment equal to mean' do
-      expect(stat.raw_moment(1)).to eq(stat.mean)
-    end
+    describe '#raw_moment' do
+      it 'calculates first raw moment equal to mean' do
+        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 eq(stat.variance)
+      it 'calculates nth raw moment correctly' do
+        expect(stat.raw_moment(3)).to eq(2.87)
+      end
     end
 
-    it 'should calculate raw moments' do
-      expect(stat.raw_moment(3)).to eq(2.87)
-    end
+    describe '#central_moment' do
+      it 'calculates second central moment equal to variance' do
+        expect(stat.central_moment(2)).to eq(stat.variance)
+      end
 
-    it 'should calculate central moments' do
-      expect(stat.central_moment(5)).to eq(6.641392040400001)
+      it 'calculates nth central moment correctly' do
+        expect(stat.central_moment(5)).to eq(6.641392040400001)
+      end
     end
 
-    it 'should calculate empirical cdf values in points' do
-      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.5)
+    describe '#empirical_cdf' do
+      it 'calculates empirical cdf values in points' do
+        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.5)
+      end
     end
 
-    it 'should calculate empirical pdf values in points' do
-      expect(stat.empirical_pdf(stat.mean)).to eq( 0.4308095750697591)
+    describe '#empirical_pdf' do
+      it 'calculates empirical pdf values in points' do
+        expect(stat.empirical_pdf(stat.mean)).to eq( 0.4308095750697591)
+      end
     end
 
-    it 'should find trend' do
-      expect(stat.trend(polynom_power: 2)).to eq('0.00042531864230840915*x^2 - 0.016860573212183233*x + 0.12239332096475111')
+    describe '#trend' do
+      it 'returns formatted trend' do
+        expect(stat.trend(polynom_power: 2)).to eq('0.00042531864230840915*x^2 - 0.016860573212183233*x + 0.12239332096475111')
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mathpack
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - maxmilan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2015-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,19 +53,21 @@ files:
 - Rakefile
 - lib/mathpack.rb
 - lib/mathpack/approximation.rb
-- lib/mathpack/equation.rb
+- lib/mathpack/functional.rb
 - lib/mathpack/functions.rb
 - lib/mathpack/integration.rb
 - lib/mathpack/io.rb
+- lib/mathpack/nonlinear_equations.rb
 - lib/mathpack/sle.rb
 - lib/mathpack/statistics.rb
 - lib/mathpack/version.rb
 - mathpack.gemspec
 - spec/approximation_spec.rb
-- spec/equation_spec.rb
+- spec/functional_spec.rb
 - spec/functions_spec.rb
 - spec/integration_spec.rb
 - spec/io_spec.rb
+- spec/nonlinear_equations_spec.rb
 - spec/sle_spec.rb
 - spec/statistics_spec.rb
 homepage: ''
@@ -88,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Summary

data/lib/mathpack/equation.rb

@@ -1,18 +0,0 @@
-module Mathpack
-  module Equation
-    def self.solve(params = {}, &function)
-      xk1 = params[:start]
-      loop do
-        xk = xk1
-        xk1 = xk - function.call(xk) / derivative(xk, &function)
-        break if (xk1 - xk).abs < params[:eps]
-      end
-      xk1
-    end
-
-    def self.derivative(xk, &function)
-      eps = 1e-5
-      (function.call(xk + eps) - function.call(xk - eps)) / (2 * eps)
-    end
-  end
-end

data/spec/equation_spec.rb

@@ -1,14 +0,0 @@
-describe 'Equations' do
-  require 'mathpack/equation'
-
-  context '#solve nonlinear equations' do
-    let(:eps) { 0.00001 }
-
-    it 'should give correct results' do
-      expect(Mathpack::Equation.solve(start: 0, eps: eps) { |x| x**2 - Math.sin(x + 1) }).to be_between(-0.613763 - eps, -0.613763 + eps)
-      expect(Mathpack::Equation.solve(start: 0.01, eps: eps) { |x| 1 / x - Math.log(x) }).to be_between(1.76322 - eps, 1.76322 + eps)
-      expect(Mathpack::Equation.solve(start: 0.01, eps: eps) { |x| x**2 - 2 * x + 1 }).to be_between(1.0 - eps, 1.0 + eps)
-      expect(Mathpack::Equation.solve(start: 0.01, eps: eps) { |x| Math.exp(x - 2) - Math.sin(x) }).to be_between(0.159396 - eps, 0.159396 + eps)
-    end
-  end
-end