malge 0.0.8 → 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ee499ce2d36b0655594c91a589d22e9eb19d704
+  data.tar.gz: 10599d6fb90300bde348a2409ecb163edf21bb0c
+SHA512:
+  metadata.gz: 5edf025d2d35ecf31d3a9254762388b650261b2f68b5a9f0f7c66f091a083eaa034db8456461b23922323af51d91605fb6672e3f52c0504c55ae58837e9fa158
+  data.tar.gz: bc2d58afee1de8dac341eafdf3c7459f55a74f4319f5f17922668a8ed712265f5f5130d5139b705f7bc80faee83462aa7872af6204920c921caeff949156a86e

data/CHANGES

@@ -1,8 +1,17 @@
-= vasputils changelog
+= malge changelog
 
-== Master (for 0.0.8)
+== Master (for 0.0.10)
 
-== Version 0.0.7)
+== Version 0.0.9 [2016-03-04] released
+* Modify errorfittedfunction to ignore most strict pair at fitting.
+* Malge::SimultaneousEquations::NotRegularError   is added
+* Malge::SimultaneousEquations::SizeMismatchError is added
+* Malge::SimultaneousEquations::NotSquareError    is added
+
+== Version 0.0.8 [2013-03-18] released
+* Small revision.
+
+== Version 0.0.7
 * Add Malge::ErrorFittedFunction::AXInv2
 * Add Malge::ErrorFittedFunction::AXInv3
 * Malge::ErrorFittedFunction may raise UnableCalculationError if contain not finit value in coefficients after fitting.

data/Gemfile

@@ -6,9 +6,10 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.2.2"
-  gem "jeweler", "~> 1.8.3"
-  gem "simplecov", ">= 0"
-  #gem "psych", ">= 0"
+  gem "test-unit", "~> 3.1"
+  gem "rdoc", "~> 4.2"
+  gem "bundler", "~> 1.11"
+  gem "jeweler", "~> 2.0"
+  gem "simplecov", "~> 0.11"
+  gem "builtinextension", ">= 0.1.3"
 end

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/malge.rb

@@ -1,5 +1,6 @@
 module Malge; end
 
+require "float/equalindelta.rb"
 require "malge/errorfittedfunction.rb"
 require "malge/errorfittedfunction/aexpbx.rb"
 require "malge/errorfittedfunction/aexpbx32.rb"
@@ -7,7 +8,9 @@ require "malge/errorfittedfunction/axinv.rb"
 require "malge/errorfittedfunction/axinv32.rb"
 require "malge/errorfittedfunction/axinv2.rb"
 require "malge/errorfittedfunction/axinv3.rb"
+require "malge/errorfittedfunction/axinv4.rb"
 require "malge/leastsquare.rb"
 require "malge/matrix.rb"
 require "malge/simultaneousequations.rb"
 require "malge/vector.rb"
+require "malge/multivariablefunction.rb"

data/lib/malge/errorfittedfunction.rb

@@ -24,8 +24,13 @@ class Malge::ErrorFittedFunction
       raise SizeMismatchError unless pair.size == 2
     end
 
-    @raw_pairs = data_pairs
-    @diff_abs_pairs = data_pairs.map { |pair| [pair[0], (pair[1] - most_strict_pair[1]).abs] }
+    #@raw_pairs = data_pairs
+    @raw_pairs = data_pairs.sort_by{|xy| xy[0]}
+    most_strict_x = most_strict_pair[0]
+    tmp_pairs = Marshal.load(Marshal.dump( @raw_pairs))
+    tmp_pairs.delete_if {|pair| pair[0] == most_strict_x}
+
+    @diff_abs_pairs = tmp_pairs.map { |pair| [pair[0], (pair[1] - most_strict_pair[1]).abs] }
     fit
 
     @coefficients.each do |coef|
@@ -52,6 +57,7 @@ class Malge::ErrorFittedFunction
   def variance
     sum = 0.0
     @diff_abs_pairs.each do |pair|
+      #pp pair
       sum += (pair[1] - expected_error(pair[0]) )**2
     end
     sum
@@ -71,6 +77,46 @@ class Malge::ErrorFittedFunction
     @raw_pairs.mix_by{ |pair| pair[0] }
   end
 
+  # Compare expected error and @raw_pairs and
+  # return a count of estimations of [equal, over, under].
+  # (order is like as result of <=>. )
+  # Excluding last data.
+  def count_equal_under_over
+    results = [0,0,0]
+    @diff_abs_pairs.each do |x,y|
+      results[expected_error(x) <=> y ] += 1
+    end
+    results
+  end
+
+  def summary(io = $stdout)
+   io.puts "Fitted function: #{equation}"
+   io.printf("%15s, %15s, %15s, %15s\n",
+      "x",
+      "raw_y",
+      "|diff_y_best|",
+      "expected_error"
+      )
+
+   datalist = []
+   @raw_pairs.size.times do |i|
+    if i != (@raw_pairs.size - 1)
+     diff = sprintf("%15.10f", @diff_abs_pairs[i][1])
+    else
+     diff = '-'*12
+    end
+
+    datalist << sprintf("%15.10f, %15.10f, %15s, %15.10f\n",
+       @raw_pairs[i][0],
+       @raw_pairs[i][1],
+       diff, 
+       expected_error(@raw_pairs[i][0])
+       )
+   end
+   io.puts datalist.sort.join
+  end
+
+
   private
 
   #Fit the data pairs to a certain function.

data/lib/malge/errorfittedfunction/aexpbx.rb

@@ -22,7 +22,7 @@ class Malge::ErrorFittedFunction::AExpBX < Malge::ErrorFittedFunction
   end
 
   def equation
-    sprintf("f(x) = %f \* exp(%f \* x)", * @coefficients)
+    sprintf("%f \* exp(%f \* x)", * @coefficients)
   end
 
   def expected_error(x)

data/lib/malge/errorfittedfunction/aexpbx32.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0] * exp(a[1] * (x ^{3/2}))
+#Assumed y = a[0] * exp(a[1] * (x **{3/2}))
 #
 #NOTE: @coefficients[0] might become negative value.
 # Need discussion for dealing?
@@ -19,19 +19,19 @@ class Malge::ErrorFittedFunction::AExpBX32 < Malge::ErrorFittedFunction
   end
 
   def equation
-    sprintf("f(x) = %f \* exp(%f \* x^{3/2})", * @coefficients)
+    sprintf("%f \* exp(%f \* x**(3.0/2.0))", * @coefficients)
   end
 
   def expected_error(x)
     @coefficients[0] * Math::exp( @coefficients[1] * x **(3.0/2.0))
   end
 
-  #y = a[0] * exp(a[1] *x^(3/2))
-  #a[0] * exp(a[1] *x^(3/2)) = y
-  #exp(a[1] *x^(3/2)) = y/a[0]
-  #a[1] *x^(3/2) = log( y/a[0])
-  #x^(3/2) = log( y/a[0])/a[1]
-  #x = (log( y/a[0])/a[1])^(2/3)
+  #y = a[0] * exp(a[1] *x**(3/2))
+  #a[0] * exp(a[1] *x**(3/2)) = y
+  #exp(a[1] *x**(3/2)) = y/a[0]
+  #a[1] *x**(3/2) = log( y/a[0])
+  #x**(3/2) = log( y/a[0])/a[1]
+  #x = (log( y/a[0])/a[1])**(2/3)
   def x(y)
     return (Math::log( y / @coefficients[0])/@coefficients[1]) **(2.0/3.0)
   end
@@ -40,7 +40,5 @@ class Malge::ErrorFittedFunction::AExpBX32 < Malge::ErrorFittedFunction
     @raw_pairs.max_by{ |pair| pair[0] }
   end
 
-
 end
 
-

data/lib/malge/errorfittedfunction/axinv.rb

@@ -7,13 +7,12 @@ class Malge::ErrorFittedFunction::AXInv < Malge::ErrorFittedFunction
 
   def fit
     inv_pairs = Marshal.load(Marshal.dump(@diff_abs_pairs))
-    #inv_pairs.delete([most_strict_x, 0.0])
     inv_pairs.map! {|pair| [1.0/pair[0], pair[1]]}
     @coefficients = Malge::LeastSquare.least_square_proportional(inv_pairs)
   end
 
   def equation
-    sprintf("f(x) = %f / x", * @coefficients)
+    sprintf("%f / x", * @coefficients)
   end
 
   def expected_error(x)

data/lib/malge/errorfittedfunction/axinv2.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0] /(x^2)
+#Assumed y = a[0] /(x**2)
 #
 class Malge::ErrorFittedFunction::AXInv2 < Malge::ErrorFittedFunction
 
@@ -11,7 +11,7 @@ class Malge::ErrorFittedFunction::AXInv2 < Malge::ErrorFittedFunction
   end
 
   def equation
-    sprintf("f(x) = %f / (x^2)", * @coefficients)
+    sprintf("%f / (x**2)", * @coefficients)
   end
 
   def expected_error(x)

data/lib/malge/errorfittedfunction/axinv3.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0]/(x^3)
+#Assumed y = a[0]/(x**3)
 #
 class Malge::ErrorFittedFunction::AXInv3 < Malge::ErrorFittedFunction
 
@@ -11,7 +11,7 @@ class Malge::ErrorFittedFunction::AXInv3 < Malge::ErrorFittedFunction
   end
 
   def equation
-    sprintf("f(x) = %f / (x^3)", * @coefficients)
+    sprintf("%f / (x**3)", * @coefficients)
   end
 
   def expected_error(x)

data/lib/malge/errorfittedfunction/axinv32.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0] /x^{3/2}
+#Assumed y = a[0] /x**{3/2}
 #
 #NOTE: @coefficients[0] might become negative value.
 # Need discussion for dealing?
@@ -13,18 +13,18 @@ class Malge::ErrorFittedFunction::AXInv32 < Malge::ErrorFittedFunction
   end
 
   def equation
-    sprintf("f(x) = %f / (x^{3/2})", * @coefficients)
+    sprintf("%f / (x**(3.0/2.0))", * @coefficients)
   end
 
   def expected_error(x)
     @coefficients[0] /(x** (3.0/2.0))
   end
 
-  #        y = a[0]/x^{3/2}
-  #        y = a[0]/x^{3/2}
-  #x^{3/2} y = a[0]
-  #  x^{3/2} = a[0]/y
-  #        x = (a[0]/y)^{2/3}
+  #                y = a[0]/x**{3/2}
+  #                y = a[0]/x**{3/2}
+  #x**{3/2} y = a[0]
+  #    x**{3/2} = a[0]/y
+  #                x = (a[0]/y)**{2/3}
   def x(y)
     return (@coefficients[0] / y ) ** (2.0/3.0)
   end
@@ -33,6 +33,5 @@ class Malge::ErrorFittedFunction::AXInv32 < Malge::ErrorFittedFunction
     @raw_pairs.max_by{ |pair| pair[0] }
   end
 
-
 end
 

data/lib/malge/errorfittedfunction/axinv4.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#Assumed y = a[0]/(x**4)
+#
+class Malge::ErrorFittedFunction::AXInv4 < Malge::ErrorFittedFunction
+
+  def fit
+    inv_pairs =  @diff_abs_pairs.map {|pair| [1.0/(pair[0]**4), pair[1]]}
+    @coefficients = Malge::LeastSquare.least_square_proportional(inv_pairs)
+  end
+
+  def equation
+    sprintf("%f / (x**4)", * @coefficients)
+  end
+
+  def expected_error(x)
+    @coefficients[0] / (x**4)
+  end
+
+  #y = a/x
+  #x = a/y
+  def x(y)
+    return (@coefficients[0] / y) ** (1.0/4.0)
+  end
+
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
+  end
+
+
+end
+

data/lib/malge/leastsquare.rb

@@ -10,11 +10,11 @@ module Malge::LeastSquare
 
   #Return values of [a_0, a_1] in y = a_0 x^0 + a_1 x^1.
   #Argument 'data_pairs' should be Array of Array's. For example,
-  #  [
-  #    [ 1.0, 2.0],
-  #    [ 2.0, 4.0],
-  #    [ 3.0, 6.0],
-  #  ]
+  #    [
+  #        [ 1.0, 2.0],
+  #        [ 2.0, 4.0],
+  #        [ 3.0, 6.0],
+  #    ]
   #Note that not [a, b] in y = ax + b.
   def self.least_square_1st_degree(data_pairs)
     a = 0.0 #x^2
@@ -52,11 +52,11 @@ module Malge::LeastSquare
 
   #Return variance when fitted to y = a_0 x^0 + a_1 x^1.
   #Argument 'data_pairs' should be Array of Array's. For example,
-  #  [
-  #    [ 1.0, 2.0],
-  #    [ 2.0, 4.0],
-  #    [ 3.0, 6.0],
-  #  ]
+  #    [
+  #        [ 1.0, 2.0],
+  #        [ 2.0, 4.0],
+  #        [ 3.0, 6.0],
+  #    ]
   def self.variance_1st_degree(data_pairs)
     coefficients = self.least_square_1st_degree(data_pairs)
     data_pairs.inject(0.0) do |sum, pair|
@@ -83,11 +83,11 @@ module Malge::LeastSquare
 
   #Return fitted values of [a, b] in a e^{bx} from more than two data points.
   #Argument 'data_pairs' should be Array of Array's. For example,
-  #  [
-  #    [ 1.0, 2.0],
-  #    [ 2.0, 4.0],
-  #    [ 3.0, 6.0],
-  #  ]
+  #    [
+  #        [ 1.0, 2.0],
+  #        [ 2.0, 4.0],
+  #        [ 3.0, 6.0],
+  #    ]
   def self.least_square_a_exp_bx(data_pairs)
     data_pairs.each do |pair|
       raise UnableCalculationError if pair[1] == 0.0

data/lib/malge/multivariablefunction.rb

@@ -0,0 +1,106 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+#
+#
+class Malge::MultiVariableFunction
+  attr_reader :data
+
+  TOLERANCE = 1E-10
+
+  # data example:
+  #   [
+  #     {x => 0.0, y => 0.1, z => 0.0},
+  #     {x => 1.0, y => 1.1, z => 1.0},
+  #     {x => 2.0, y => 2.1, z => 3.0},
+  #   ]
+  #
+  def initialize(data)
+    @data = data
+  end
+
+  # Return array of data which matches the hash.
+  def abstract!(conditions)
+    results = @data.select do |coords|
+      match_condition?(coords, conditions)
+    end
+    @data = results
+  end
+
+  def abstract(conditions)
+    result = Marshal.load(Marshal.dump(self))
+    result.abstract!(conditions)
+    result
+  end
+
+  # unite axes with the same value.
+  # keys : [:a, :b]
+  # new_key : default is keys[0]
+  def unite_axes!(keys, new_key = nil)
+    new_key ||= keys[0]
+    results = []
+    @data.each do |datum|
+      new_datum = Marshal.load(Marshal.dump(datum))
+      if same?(new_datum, keys)
+        val = new_datum[keys[0]]
+        keys.each {|key| new_datum.delete(key) }
+        new_datum[new_key] = val
+        results << new_datum
+      end
+    end
+    @data = results
+  end
+
+  def unite_axes(keys, new_key = nil)
+    result = Marshal.load(Marshal.dump(self))
+    result.unite_axes!(keys, new_key)
+    result
+  end
+
+  def delete_axis!(axis)
+    @data.each do |datum|
+      datum.delete axis
+    end
+  end
+
+  def delete_axis(axis)
+    result = Marshal.load(Marshal.dump(self))
+    result.delete_axis!(axis)
+    result
+  end
+
+  # return 2-dimensional array.
+  # [
+  #   [x0, y0],
+  #   [x1, y1],
+  #   :
+  # ]
+  def data_pairs(key0, key1)
+    results = []
+    @data.each do |datum|
+      results << [datum[key0], datum[key1]]
+    end
+    results
+  end
+
+  private
+
+  #if when the same value among keys, return true.
+  #if not, return false.
+  def same?(datum, keys, tolerance = TOLERANCE)
+    ref = datum[keys[0]]
+    keys.each do |key|
+      return false unless ref.to_f.equal_in_delta?(datum[key].to_f, tolerance)
+    end
+    return true
+  end
+
+  def match_condition?(datum, conditions)
+    conditions.each do |key, val|
+      return false unless datum[key] == val
+    end
+  end
+
+end
+