mathpack 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4149b86761de55b123f4feeef355ea0aa0051f2
-  data.tar.gz: 3b5f7106a2354c0f3ac20e3500a2667f1879aeff
+  metadata.gz: 111c0ff1891e4a3c36c9b93e8f76c6e95e6d3daa
+  data.tar.gz: 3356428babcbf1b7031dc7dfbd4c03a397dc565c
 SHA512:
-  metadata.gz: 6ff0997ccc70491bfb436075065e3e4d7eae4dbef76aff64d7969da9659cb76ff50e7ac2147fbe76dc272b8adfd5ebfddd60e64c43adb3a858acd43e83e770ba
-  data.tar.gz: 7c6a0502aad9840247e3616982e97e9752597fa3741cc6cb1d0869c96a115ca12a620440042e9b63014d3179fab988efc48690e5543266f52c285f533576acd7
+  metadata.gz: 4f04c1e83d260b0376c79b7899092d878b8f5f3b9dedcc40963a931ca0a5b200a8770598164429678fb2d02d1af14d4d99569a4000c633ced33882f617e2fa6d
+  data.tar.gz: 39e0707d6eabb22509488221178fe14322d391934a248e8092ddef5050d0a1902755cba9af1698a01d1146046ad489c457b2b82ac2e82f75ae508df6444865d8

data/README.md

@@ -34,7 +34,7 @@ Gem `mathpack` allows to count statistical functions through `Statistics` class,
 - **empirical_cdf** - returns *empirical distribution function* value in some point
 - **empirical_pdf** - returns *empirical probability density function* value in some point
 - **print_empirical_cdf_to_csv** - allows to print empirical_cdf line chart values to `.csv` file with name *filename*
-- **print_empirical_cdf_to_csv** - allows to print empirical_cdf line chart values to `.csv` file with name *filename*
+- **print_empirical_pdf_to_csv** - allows to print empirical_pdf line chart values to `.csv` file with name *filename*
 - **trend** - returns trend polynom
 
 ### Usage
@@ -43,7 +43,7 @@ stat = Mathpack::Statistics.new([1, 2, 5, 6])
 stat.number() #=> 4
 stat.mean() #=> 3.5
 stat.variance() #=> 4.25
-stat.kurtosis() #=> 1.221453287197232
+stat.kurtosis() #=> -1.778546712802768
 stat.skewness() #=> 0.0
 stat.min() #=> 1
 stat.max() #=> 6
@@ -117,23 +117,54 @@ manage with this problem using `Approximation` module. This module uses least sq
 ### Usage
 ```ruby
 # Function to print polynom having it's coefficients
-Mathpack::Approximation::print_polynom([1, -2, 1]) #=> x^2 - 2*x + 1
+Mathpack::Approximation.print_polynom([1, -2, 1]) #=> x^2 - 2*x + 1
 
 # Function to generate nodes for approximation. Only choose start value, end value and step
-x = Mathpack::Approximation::generate_nodes(start: 0, end: 10, step: 0.25)
+x = Mathpack::Approximation.generate_nodes(from: 0, to: 10, step: 0.25)
 #=> [0, 0.25, ..., 10]
 
 # Function that approximate given function by polynom with power polynom_power in approximation nodes x and returns coefficients of approximating polynom
-result = Mathpack::Approximation::approximate_by_polynom(x: x, polynom_power: 5){ |x| Math.sin(x) }
+result = Mathpack::Approximation.approximate_by_polynom(x: x, polynom_power: 5){ |x| Math.sin(x) }
 #=> [0.0008009744982571882, -0.030619986086758588, 0.3805927651948083, -1.8481035413353888, 2.985465287759307, -0.3873066069630569]
 
 # May be you want to print this polynom, let's call print_polynom function
-Mathpack::Approximation::print_polynom(result)
+Mathpack::Approximation.print_polynom(result)
 #=> 0.0008009744982571882*x^5 - 0.030619986086758588*x^4 + 0.3805927651948083*x^3 - 1.8481035413353888*x^2 + 2.985465287759307*x - 0.3873066069630569
 
 # If you have a table of values, where x - array of arguement values and f - array of function values, call approximate by polynom function with parameter f instead of block
-result = Mathpack::Approximation::approximate_by_polynom(x: [1, 2, 3], f: [1, 4, 9], polynom_power: 2) #=> [1, 0, 0]
-Mathpack::Approximation::print_polynom(result) #=> x^2
+result = Mathpack::Approximation.approximate_by_polynom(x: [1, 2, 3], f: [1, 4, 9], polynom_power: 2) #=> [1, 0, 0]
+Mathpack::Approximation.print_polynom(result) #=> x^2
+```
+
+## Integration
+`Integration` module has method `integrate`, which is used to integrate numericality various functions.
+
+### Usage
+Let you have the following integral:
+
+![equation](http://latex.codecogs.com/gif.latex?%5Cint_%7Ba%7D%5E%7Bb%7Df%28x%29dx)
+
+Where *a* can be finite or equal to ![equation](http://latex.codecogs.com/gif.latex?-%5Cinfty), and *b* can be finite or equal to ![equation](http://latex.codecogs.com/gif.latex?%5Cinfty). To find value of integral you should call **integrate** method of Integration module.
+```ruby
+Mathpack::Integration.integrate(from: a, to: b){ |x| f(x) }
+```
+Let's demostrate some examples of Integration module practical usage:
+```ruby
+Mathpack::Integration.integrate(from: 0, to: 3.6){ |x| Math.sin(x) / x } #=> 1.8219481156495034
+Mathpack::Integration.integrate(from: 0, to: Float::INFINITY){ |x| Math.exp(-x) / (x + 1) } #=> 0.5963473623136091
+Mathpack::Integration.integrate(from: -Float::INFINITY, to: Float::INFINITY){ |x| Math.exp(-x**2) * Math.cos(x) } #=> 1.3803884100161075
+```
+
+## IO
+
+`IO` module allows to output complex data
+
+### 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 `.csv` file.
+```ruby
+Mathpack::IO.print_table_function(filename: 'table.csv', x: [1, 2, 3], y: [2, 4, 6], labels: { x: 'x', y: 'f(x)'}
 ```
 
 ## Contributing

data/lib/mathpack/approximation.rb

@@ -57,11 +57,11 @@ module Mathpack
       nodes = []
       i = 0
       loop do
-        nodes << params[:start] + i * params[:step]
+        nodes << params[:from] + i * params[:step]
         i += 1
-        break if params[:start] + i * params[:step] > params[:end]
+        break if params[:from] + i * params[:step] > params[:to]
       end
-      nodes << params[:end] if nodes.last != params[:end]
+      nodes << params[:to] if nodes.last != params[:to]
       nodes
     end
 

data/lib/mathpack/integration.rb

@@ -5,7 +5,10 @@ module Mathpack
 
     def self.integrate(params = {}, &f)
       if params[:from] == -Float::INFINITY && params[:to] == Float::INFINITY
-        result = solve_ni_2(&f)
+        result = solve_oi(-INTEGRATION_LIMIT, INTEGRATION_LIMIT, &f)
+        g = ->(x) { f.call(-x) }
+        result += solve_ni_1(INTEGRATION_LIMIT, &g)
+        result += solve_ni_1(INTEGRATION_LIMIT, &f)
       elsif params[:to] == Float::INFINITY || params[:from] == -Float::INFINITY
         if params[:from] == -Float::INFINITY
           params[:from] = -params[:to]
@@ -29,7 +32,7 @@ module Mathpack
 
     def self.solve_oi(from, to, &f)
       result = 0.0
-      nodes = Mathpack::Approximation.generate_nodes(start: from, end: to, step: STEP)
+      nodes = Mathpack::Approximation.generate_nodes(from: from, to: to, step: STEP)
       for i in 0...nodes.length - 1  do
         result += basic_integrate(nodes[i], nodes[i + 1], &f)
       end
@@ -46,15 +49,5 @@ module Mathpack
       end
       result
     end
-
-    def self.solve_ni_2(&f)
-      result = 0.0
-      coefficients_array = [0.004530009906, 0.1570673203, 0.7246295952, 0.7246295952, 0.1570673203, 0.004530009906]
-      nodes_array = [-2.3506049737, -1.3358490740, -0.4360774119, 0.4360774119, 1.3358490740, 2.3506049737]
-      nodes_array.each_index do |i|
-        result += coefficients_array[i] * Math.exp(nodes_array[i]**2) * f.call(nodes_array[i])
-      end
-      result
-    end
   end
 end

data/lib/mathpack/io.rb

@@ -0,0 +1,13 @@
+module Mathpack
+  module IO
+    def self.print_table_function(params = {})
+      fail 'Arrays length dismatch' if params[:x].length != params[:y].length
+      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")
+        end
+      end
+    end
+  end
+end

data/lib/mathpack/sle.rb

@@ -6,11 +6,12 @@ module Mathpack
 
     def self.solve(params)
       type = params[:f].class
-      @matrix = params[:matrix].dup.to_a
-      @f = params[:f].dup.to_a.flatten
+      @matrix = Marshal.load(Marshal.dump(params[:matrix])).to_a
+      @f = params[:f].to_a.flatten
+      fail 'Incorrect size of array or vector' unless @matrix.length == @matrix.first.length && @matrix.length == @f.length
       @number = @f.length
       @x = Array.new(@number) { |i| i + 1 }
-      fail 'SLE can\'t be solved' unless solve_direct
+      fail 'Matrix is singular' unless solve_direct
       type == Matrix ? Matrix.row_vector(solve_reverse) : solve_reverse
     end
 

data/lib/mathpack/statistics.rb

@@ -2,6 +2,7 @@ module Mathpack
   class Statistics
     def initialize(series)
       @series = series
+      @data_set, @frequency = parse_series(series)
     end
 
     def number
@@ -21,27 +22,31 @@ module Mathpack
     end
 
     def kurtosis
-      central_moment(4) / variance**2
+      central_moment(4) / variance**2 - 3.0
     end
 
     def max
-      @series.max
+      @data_set.max
     end
 
     def min
-      @series.min
+      @data_set.min
     end
 
     def raw_moment(power)
       raw_moment = 0.0
-      @series.each { |x| raw_moment += x**power }
+      @data_set.each_index do |i|
+        raw_moment += @frequency[i] * @data_set[i]**power
+      end
       raw_moment / number
     end
 
     def central_moment(power)
       central_moment = 0.0
       m = mean
-      @series.each { |x| central_moment += (x - m)**power }
+      @data_set.each_index do |i|
+        central_moment += @frequency[i] * (@data_set[i] - m)**power
+      end
       central_moment / number
     end
 
@@ -53,14 +58,9 @@ module Mathpack
 
     def print_empirical_cdf_to_csv(filename)
       step = 0.5 * (max - min) / number
-      val = min - step
-      File.open(filename, 'w+') do |file|
-        while val <= max + step
-          file.write("#{val};")
-          file.write("#{empirical_cdf(val)}\n")
-          val += step
-        end
-      end
+      nodes = Mathpack::Approximation.generate_nodes(from: min - step, to: max + step, step: step)
+      values = nodes.map { |x| empirical_cdf(x) }
+      Mathpack::IO.print_table_function(filename: filename, x: nodes, y: values)
     end
 
     def empirical_pdf(x)
@@ -72,14 +72,9 @@ module Mathpack
 
     def print_empirical_pdf_to_csv(filename)
       step = 0.5 * (max - min) / number
-      val = min - 10 * step
-      File.open(filename, 'w+') do |file|
-        while val <= max + 10 * step
-          file.write("#{val};")
-          file.write("#{empirical_pdf(val)}\n")
-          val += step
-        end
-      end
+      nodes = Mathpack::Approximation.generate_nodes(from: min - 10 * step, to: max + 10 * step, step: step)
+      values = nodes.map { |x| empirical_pdf(x) }
+      Mathpack::IO.print_table_function(filename: filename, x: nodes, y: values)
     end
 
     def trend(params = {})
@@ -93,5 +88,19 @@ module Mathpack
     def heaviside(x)
       x <= 0 ? 0 : 1
     end
+
+    def parse_series(series)
+      data_set = []
+      frequency = []
+      series.each do |element|
+        if data_set.include? element
+          frequency[data_set.index(element)] += 1
+        else
+          data_set << element
+          frequency[data_set.index(element)] = 1
+        end
+      end
+      [data_set, frequency]
+    end
   end
 end

data/lib/mathpack/version.rb

@@ -1,3 +1,3 @@
 module Mathpack
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/lib/mathpack.rb

@@ -4,3 +4,4 @@ require 'mathpack/equation'
 require 'mathpack/sle'
 require 'mathpack/approximation'
 require 'mathpack/integration'
+require 'mathpack/io'

data/spec/approximation_spec.rb

@@ -5,7 +5,7 @@ describe 'Approximation' do
     let(:x_start) { 0.0 }
     let(:x_end) { 10.0 }
     let(:step) { 0.25 }
-    let(:nodes) { Mathpack::Approximation.generate_nodes(start: x_start, end: x_end, step: step) }
+    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
@@ -15,7 +15,7 @@ describe 'Approximation' do
     end
 
     it 'should generate correct nodes' do
-      nodes = Mathpack::Approximation.generate_nodes(start: 0, end: 1, step: 0.001)
+      nodes = Mathpack::Approximation.generate_nodes(from: 0, to: 1, step: 0.001)
       expect(nodes.last).to eq(1.0)
     end
 

data/spec/sle_spec.rb

@@ -12,12 +12,26 @@ describe 'SLE' do
       expect(Mathpack::SLE.solve(matrix: a, f: b)).to eq([-1.0, 2.0, 4.0])
     end
 
-    it 'should raise error' do
+    it 'should raise 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
+      b << 1
+      expect { Mathpack::SLE.solve(matrix: a, f: b) }.to raise_error
+      b.pop
+      a << [1, 2, 3, 4]
+      expect { Mathpack::SLE.solve(matrix: a, f: b) }.to raise_error
+    end
+
     it 'should return 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
+
+    it 'should not change source data' do
+      Mathpack::SLE.solve(matrix: a, f: b)
+      expect(a).to eq([[1, 2, 3], [4, 5, 6], [3, 5, 2]])
+      expect(b).to eq([15, 30, 15])
+    end
   end
 end

data/spec/statistics_spec.rb

@@ -3,35 +3,43 @@ describe 'Statistics' do
 
   describe '#calculate statistics functions' do
 
-    let(:data) { [1, 5, 4, 2, 3, 4, 5, 7, 2, 7] }
+    let(:data) do
+      array = []
+      array << [0]*50
+      array << [1]*35
+      array << [2]*10
+      array << [3]*4
+      array << [4]*1
+      array.flatten
+    end
     let(:stat) { Mathpack::Statistics.new(data) }
 
     it 'should calculate number of elements' do
-      expect(stat.number).to eq(10)
+      expect(stat.number).to eq(100)
     end
 
     it 'should calculate mean' do
-      expect(stat.mean).to eq(4.0)
+      expect(stat.mean).to eq(0.71)
     end
 
     it 'should calculate variance' do
-      expect(stat.variance).to eq(3.8)
+      expect(stat.variance).to eq(0.7659)
     end
 
     it 'should calculate skewness' do
-      expect(stat.skewness).to eq(0.16199658190818222)
+      expect(stat.skewness).to eq(1.3139557526940238)
     end
 
     it 'should calculate kurtosis' do
-      expect(stat.kurtosis).to eq(1.925207756232687)
+      expect(stat.kurtosis).to eq(1.5654257435282322)
     end
 
     it 'should calculate the minimal element' do
-      expect(stat.min).to eq(1)
+      expect(stat.min).to eq(0)
     end
 
     it 'should calculate the maximal element' do
-      expect(stat.max).to eq(7)
+      expect(stat.max).to eq(4)
     end
 
     it 'should calculate first raw moment equal to mean' do
@@ -43,25 +51,25 @@ describe 'Statistics' do
     end
 
     it 'should calculate raw moments' do
-      expect(stat.raw_moment(3)).to eq(110.8)
+      expect(stat.raw_moment(3)).to eq(2.87)
     end
 
     it 'should calculate central moments' do
-      expect(stat.central_moment(5)).to eq(18.0)
+      expect(stat.central_moment(5)).to eq(6.641392040400001)
     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.4)
+      expect(stat.empirical_cdf(stat.mean)).to eq(0.5)
     end
 
     it 'should calculate empirical pdf values in points' do
-      expect(stat.empirical_pdf(stat.mean)).to eq(0.1882412842233359)
+      expect(stat.empirical_pdf(stat.mean)).to eq( 0.4308095750697591)
     end
 
     it 'should find trend' do
-      expect(stat.trend(polynom_power: 2)).to eq('0.0075757575757576055*x^2 + 0.2681818181818179*x + 2.233333333333334')
+      expect(stat.trend(polynom_power: 2)).to eq('0.00042531864230840915*x^2 - 0.016860573212183233*x + 0.12239332096475111')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mathpack
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - maxmilan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-22 00:00:00.000000000 Z
+date: 2015-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,6 +55,7 @@ files:
 - lib/mathpack/approximation.rb
 - lib/mathpack/equation.rb
 - lib/mathpack/integration.rb
+- lib/mathpack/io.rb
 - lib/mathpack/sle.rb
 - lib/mathpack/statistics.rb
 - lib/mathpack/version.rb