minimization 0.1.1 → 0.2.0

data/History.txt

@@ -1,3 +1,6 @@
+=== 0.2.0 / 2010-04-15
+* New Minimization::NewtonRahpson class, which implements a naive  Newton-Rahpson minimization method 
+  x=x_n-(f'(x)/f''(x))
 === 0.1.1 / 2010-03-19
 
 * New Minimization#minimize convenience method

data/Manifest.txt

@@ -4,4 +4,6 @@ Manifest.txt
 README.txt
 Rakefile
 lib/minimization.rb
-test/test_minimization.rb
+spec/minimization_unidimensional_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/README.txt

@@ -9,6 +9,7 @@ Minimization algorithms on pure Ruby.
 == FEATURES/PROBLEMS:
 
 Unidimensional:
+* Newton-Rahpson (requires first and second derivative)
 * Golden Section
 * Brent (Port of GSL code)
 

data/Rakefile

@@ -3,12 +3,14 @@
 require 'rubygems'
 require 'hoe'
 require './lib/minimization'
+Hoe.plugin :git
 
 Hoe.spec 'minimization' do
 	self.version=Minimization::VERSION
 	self.rubyforge_name = 'ruby-statsample' # if different than 'minimization'
 	self.developer('Claudio Bustos', 'clbustos_AT_gmail.com')
 	self.remote_rdoc_dir = 'minimization'
+    self.extra_deps << ['text-table', "~>1.2"]
 end
 
 # vim: syntax=ruby

data/lib/minimization.rb

@@ -1,4 +1,4 @@
-# = minimization.rb - 
+# = minimization.rb -
 # Minimization- Minimization algorithms on pure Ruby
 # Copyright (C) 2010 Claudio Bustos
 #
@@ -16,353 +16,428 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
-
+require 'text-table'
+# Algorithms for unidimensional minimization
 module Minimization
-
-	VERSION="0.1.1"
-	FailedIteration=Class.new(Exception)
+  VERSION="0.2.0"
+  FailedIteration=Class.new(Exception)
   # Base class for unidimensional minimizers
-	class Unidimensional
-		# Default value for error
-		EPSILON=1e-6
-		# Default number of maximum iterations
-		MAX_ITERATIONS=100
-		# Minimum value for x
-		attr_reader :x_minimum
-		# Minimum value for f(x)
-		attr_reader :f_minimum
-		# Log of iterations
-		attr_reader :log
-		# Absolute error on x
-		attr_accessor :epsilon
-		# Create a new minimizer
-		def initialize(lower, upper, proc)
-			raise "first argument  should be lower than second" if lower>=upper
-			@lower=lower
-			@upper=upper
-			@proc=proc
-			golden = 0.3819660;
-			@expected = @lower + golden * (@upper - @lower);
-			@max_iteration=MAX_ITERATIONS
-			@epsilon=EPSILON
-			@iterations=0
-			@log=""
+  class Unidimensional
+    # Default value for error on f(x)
+    EPSILON=1e-6
+    # Default number of maximum iterations
+    MAX_ITERATIONS=100
+    # Minimum value for x
+    attr_reader :x_minimum
+    # Minimum value for f(x)
+    attr_reader :f_minimum
+    # Log of iterations. Should be an array
+    attr_reader :log
+    # Name of fields of log
+    attr_reader :log_header
+    # Absolute error on x
+    attr_accessor :epsilon
+    # Expected value. Fast minimum finding if set
+    attr_reader :expected
+    # Create a new minimizer
+    def initialize(lower, upper, proc)
+      raise "first argument  should be lower than second" if lower>=upper
+      @lower=lower
+      @upper=upper
+      @proc=proc
+      golden = 0.3819660;
+      @expected = @lower + golden * (@upper - @lower);
+      @max_iteration=MAX_ITERATIONS
+      @epsilon=EPSILON
+      @iterations=0
+      @log=[]
+      @log_header=%w{I xl xh f(xl) f(xh) dx df(x)}
+    end
+    # Set expected value
+    def expected=(v)
+      @expected=v
+    end
+    def log_summary
+      @log.join("\n")
     end
     # Convenience method to minimize
-    # Usage:
+    # == Parameters:
+    # * <tt>lower</tt>: Lower possible value
+    # * <tt>upper</tt>: Higher possible value
+    # * <tt>expected</tt>: Optional expected value. Faster the search is near correct value.
+    # * <tt>&block</tt>: Block with function to minimize
+    # == Usage:
     #   minimizer=Minimization::GoldenSection.minimize(-1000, 1000) {|x|
     #             x**2 }
-    #
+    # 
     def self.minimize(lower,upper,expected=nil,&block)
       minimizer=new(lower,upper,block)
       minimizer.expected=expected unless expected.nil?
       raise FailedIteration unless minimizer.iterate
       minimizer
     end
-	  def f(x)
+    # Iterate to find the minimum
+    def iterate
+      raise "You should implement this"
+    end
+    def f(x)
       @proc.call(x)
     end
-	end
-    # = Golden Section Minimizer.
-	# Basic minimization algorithm. Slow, but robust
-    # Use:
-	#  require 'minimization'
-	#  min=Minimization::GoldenSection.new(-1000,20000  , proc {|x| (x+1)**2}
-	#  min.expected=1.5  # Expected value
-	#  min.iterate
-	#  min.x_minimum
-	#  min.f_minimum
-	#  min.log
+  end
+  # Classic Newton-Raphson minimization method.  
+  # Requires first and second derivative
+  # == Usage
+  #   f   = lambda {|x| x**2}
+  #   fd  = lambda {|x| 2x}
+  #   fdd = lambda {|x| 2}
+  #   min = Minimization::NewtonRaphson.new(-1000,1000, f,fd,fdd)
+  #   min.iterate
+  #   min.x_minimum
+  #   min.f_minimum
+  #   
+  class NewtonRaphson < Unidimensional
+    # == Parameters:
+    # * <tt>lower</tt>: Lower possible value
+    # * <tt>upper</tt>: Higher possible value
+    # * <tt>proc</tt>: Original function
+    # * <tt>proc_1d</tt>: First derivative
+    # * <tt>proc_2d</tt>: Second derivative
+    # 
+    def initialize(lower, upper, proc, proc_1d, proc_2d)
+      super(lower,upper,proc)
+      @proc_1d=proc_1d
+      @proc_2d=proc_2d
+    end
+    # Raises an error
+    def self.minimize(*args)
+      raise "You should use #new and #iterate"
+    end
+    def iterate
+      # First
+      x_prev=@lower
+      x=@expected
+      failed=true
+      k=0
+      while (x-x_prev).abs > @epsilon and k<@max_iteration
+        k+=1
+        x_prev=x
+        x=x-(@proc_1d.call(x).quo(@proc_2d.call(x)))
+        f_prev=f(x_prev)
+        f=f(x)
+        x_min,x_max=[x,x_prev].min, [x,x_prev].max 
+        f_min,f_max=[f,f_prev].min, [f,f_prev].max 
+        @log << [k, x_min, x_max, f_min, f_max, (x_prev-x).abs, (f-f_prev).abs]
+      end
+      raise FailedIteration, "Not converged" if k>=@max_iteration
+      @x_minimum = x;
+      @f_minimum = f(x);
+    end
+  end
+  # = Golden Section Minimizer.
+  # Basic minimization algorithm. Slow, but robust.
+  # See Unidimensional for methods.
+  # == Usage.
+  #  require 'minimization'
+  #  min=Minimization::GoldenSection.new(-1000,20000  , proc {|x| (x+1)**2}
+  #  min.expected=1.5  # Expected value
+  #  min.iterate
+  #  min.x_minimum
+  #  min.f_minimum
+  #  min.log
   class GoldenSection < Unidimensional
-	  attr_accessor :expected
-    def initialize(lower,upper, proc)
-		  super
-	  end
-      # Start the iteration
-      def iterate
-        ax=@lower
-        bx=@expected
-        cx=@upper
-        c = (3-Math::sqrt(5)).quo(2);
-        r = 1-c;
- 
-        x0 = ax;
-        x3 = cx;
-        if ((cx-bx).abs > (bx-ax).abs)
-          x1 = bx;
-          x2 = bx + c*(cx-bx);
-        else
-          x2 = bx;
-          x1 = bx - c*(bx-ax);
-        end
-        f1 = f(x1);
-        f2 = f(x2);
-         
-        k = 1;
-		
-		
-		
-        while (x3-x0).abs > @epsilon and k<@max_iteration
-          @log+=sprintf("k=%4d, |a-b|=%e\n", k, (x3-x0).abs)
-          if f2 < f1
-            x0 = x1;
-            x1 = x2;
-            x2 = r*x1 + c*x3;   # x2 = x1+c*(x3-x1)
-            f1 = f2;
-            f2 = f(x2);
-          else
-            x3 = x2;
-            x2 = x1;
-            x1 = r*x2 + c*x0;   # x1 = x2+c*(x0-x2)
-            f2 = f1;
-            f1 = f(x1);
-          end
-          k +=1;
-        end
-         
-        if f1 < f2
-          @x_minimum = x1;
-          @f_minimum = f1;
+    # Start the iteration
+    def iterate
+      ax=@lower
+      bx=@expected
+      cx=@upper
+      c = (3-Math::sqrt(5)).quo(2);
+      r = 1-c;
+
+      x0 = ax;
+      x3 = cx;
+      if ((cx-bx).abs > (bx-ax).abs)
+        x1 = bx;
+        x2 = bx + c*(cx-bx);
+      else
+        x2 = bx;
+        x1 = bx - c*(bx-ax);
+      end
+      f1 = f(x1);
+      f2 = f(x2);
+
+      k = 1;
+
+
+
+      while (x3-x0).abs > @epsilon and k<@max_iteration
+        if f2 < f1
+          x0 = x1;
+          x1 = x2;
+          x2 = r*x1 + c*x3;   # x2 = x1+c*(x3-x1)
+          f1 = f2;
+          f2 = f(x2);
         else
-          @x_minimum = x2;
-          @f_minimum = f2;
+          x3 = x2;
+          x2 = x1;
+          x1 = r*x2 + c*x0;   # x1 = x2+c*(x0-x2)
+          f2 = f1;
+          f1 = f(x1);
         end
-		true
+        @log << [k, x3,x0, f1,f2,(x3-x0).abs, (f1-f2).abs]
+        
+        k +=1;
       end
 
+      if f1 < f2
+        @x_minimum = x1;
+        @f_minimum = f1;
+      else
+        @x_minimum = x2;
+        @f_minimum = f2;
+      end
+      true
+    end
+
+  end
+
+  # Direct port of Brent algorithm found on GSL.
+  # See Unidimensional for methods.
+  # == Usage
+  #  min=Minimization::Brent.new(-1000,20000  , proc {|x| (x+1)**2}
+  #  min.expected=1.5  # Expected value
+  #  min.iterate
+  #  min.x_minimum
+  #  min.f_minimum
+  #  min.log
+
+  class Brent < Unidimensional
+    GSL_SQRT_DBL_EPSILON=1.4901161193847656e-08
+    def initialize(lower,upper, proc)
+      super
+
+      @do_bracketing=true
+
+      # Init
+
+      golden = 0.3819660;      #golden = (3 - sqrt(5))/2
+
+      v = @lower + golden * (@upper - @lower);
+      w = v;
+
+      @x_minimum = v ;
+      @f_minimum = f(v) ;
+      @x_lower=@lower
+      @x_upper=@upper
+      @f_lower = f(@lower) ;
+      @f_upper = f(@lower) ;
+
+      @v = v;
+      @w = w;
+
+      @d = 0;
+      @e = 0;
+      @f_v=f(v)
+      @f_w=@f_v
+    end
+
+    def expected=(v)
+      @x_minimum=v
+      @f_minimum=f(v)
+      @do_bracketing=false
     end
     
-    # Direct port of Brent algorithm found on GSL
-	#  min=Minimization::Brent.new(-1000,20000  , proc {|x| (x+1)**2}
-	#  min.expected=1.5  # Expected value
-	#  min.iterate
-	#  min.x_minimum
-	#  min.f_minimum
-	#  min.log
-	
-    class Brent < Unidimensional
-      GSL_SQRT_DBL_EPSILON=1.4901161193847656e-08
-      def initialize(lower,upper, proc)
-        super
-
-		@do_bracketing=true
-
-        # Init
-
-        golden = 0.3819660;      #golden = (3 - sqrt(5))/2 
-        
-        v = @lower + golden * (@upper - @lower);
-        w = v;
-        
-        @x_minimum = v ;  
-        @f_minimum = f(v) ;
-        @x_lower=@lower
-        @x_upper=@upper
-        @f_lower = f(@lower) ;
-        @f_upper = f(@lower) ;
-        
-        @v = v;
-        @w = w;
-        
-        @d = 0;
-        @e = 0;
-        @f_v=f(v)
-        @f_w=@f_v
-	end
-	
-      def expected=(v)
-        @x_minimum=v
-        @f_minimum=f(v)
-        @do_bracketing=false
+    def bracketing
+      eval_max=10
+      f_left = @f_lower;
+      f_right = @f_upper;
+      x_left = @x_lower;
+      x_right= @x_upper;
+      golden = 0.3819660;      # golden = (3 - sqrt(5))/2 */
+      nb_eval=0
+
+      if (f_right >= f_left)
+        x_center = (x_right - x_left) * golden + x_left;
+        nb_eval+=1;
+        f_center=f(x_center)
+      else
+        x_center = x_right ;
+        f_center = f_right ;
+        x_right = (x_center - x_left).quo(golden) + x_left;
+        nb_eval+=1;
+        f_right=f(x_right);
       end
-      def bracketing
-        eval_max=10
-        f_left = @f_lower;
-        f_right = @f_upper;
-        x_left = @x_lower;
-        x_right= @x_upper; 
-        golden = 0.3819660;      # golden = (3 - sqrt(5))/2 */
-        nb_eval=0
-        
-        if (f_right >= f_left)
-          x_center = (x_right - x_left) * golden + x_left;
-          nb_eval+=1;
-          f_center=f(x_center)
-        else
-          x_center = x_right ;
-          f_center = f_right ;
-          x_right = (x_center - x_left).quo(golden) + x_left;
-          nb_eval+=1;
-          f_right=f(x_right);
-        end
-        
-        
-        begin
-          @log+=sprintf("B%d: [%0.5f - %0.5f] ->  [%0.5f - %0.5f] E: %0.6f\n", nb_eval, x_left, x_right, f_left, f_right, (x_left-x_right).abs)
-          if (f_center < f_left )
-            if (f_center < f_right)
-              @x_lower = x_left;
-              @x_upper = x_right;
-              @x_minimum = x_center;
-              @f_lower = f_left;
-              @f_upper = f_right;
-              @f_minimum = f_center;
-              return true;
-            elsif (f_center > f_right)
-              x_left = x_center;
-              f_left = f_center;
-              x_center = x_right;
-              f_center = f_right;
-              x_right = (x_center - x_left).quo(golden) + x_left;
-              nb_eval+=1;
-              f_right=f(x_right);
-            else # f_center == f_right */
-              x_right = x_center;
-              f_right = f_center;
-              x_center = (x_right - x_left).quo(golden) + x_left;
-              nb_eval+=1;
-              f_center=f(x_center);
-            end
-          else # f_center >= f_left */
+
+
+      begin
+        @log << ["B#{nb_eval}", x_left, x_right, f_left, f_right, (x_left-x_right).abs, (f_left-f_right).abs]
+        if (f_center < f_left )
+          if (f_center < f_right)
+            @x_lower = x_left;
+            @x_upper = x_right;
+            @x_minimum = x_center;
+            @f_lower = f_left;
+            @f_upper = f_right;
+            @f_minimum = f_center;
+            return true;
+          elsif (f_center > f_right)
+            x_left = x_center;
+            f_left = f_center;
+            x_center = x_right;
+            f_center = f_right;
+            x_right = (x_center - x_left).quo(golden) + x_left;
+            nb_eval+=1;
+            f_right=f(x_right);
+          else # f_center == f_right */
             x_right = x_center;
             f_right = f_center;
-            x_center = (x_right - x_left) * golden + x_left;
+            x_center = (x_right - x_left).quo(golden) + x_left;
             nb_eval+=1;
             f_center=f(x_center);
           end
-        end while ((nb_eval < eval_max) and
-          ((x_right - x_left) > GSL_SQRT_DBL_EPSILON * ( (x_right + x_left) * 0.5 ) + GSL_SQRT_DBL_EPSILON))
-        @x_lower = x_left;
-        @x_upper = x_right;
-        @x_minimum = x_center;
-        @f_lower = f_left;
-        @f_upper = f_right;
-        @f_minimum = f_center;
-        return false;
-        
-	end
-	# Start the minimization process
-	# If you want to control manually the process, use brent_iterate
-      def iterate
-        k=0
-        bracketing if @do_bracketing
-        while k<@max_iteration and (@x_lower-@x_upper).abs>@epsilon
-          k+=1
-          result=brent_iterate
-          raise "Error on iteration" if !result
-          @log+=sprintf("%d: [%0.5f - %0.5f] ->  [%0.5f - %0.5f] E: %0.6f\n", k, @x_lower, @x_upper, @f_lower, @f_upper, (@x_lower-@x_upper).abs)
+        else # f_center >= f_left */
+          x_right = x_center;
+          f_right = f_center;
+          x_center = (x_right - x_left) * golden + x_left;
+          nb_eval+=1;
+          f_center=f(x_center);
         end
-        @iterations=k
-        return true
-	end
-	 # Generate one iteration.
-      def brent_iterate
-        x_left = @x_lower;
-        x_right = @x_upper;
-        
-        z = @x_minimum;
-        d = @e;
-        e = @d;
-        v = @v;
-        w = @w;
-        f_v = @f_v;
-        f_w = @f_w;
-        f_z = @f_minimum;
-        
-        golden = 0.3819660;      # golden = (3 - sqrt(5))/2 */
-        
-        w_lower = (z - x_left)
-        w_upper = (x_right - z)
-        
-        tolerance =  GSL_SQRT_DBL_EPSILON * z.abs
-        
-        midpoint = 0.5 * (x_left + x_right)
-_p,q,r=0,0,0
-        if (e.abs > tolerance)
-          
-          # fit parabola */
-          
-          r = (z - w) * (f_z - f_v);
-          q = (z - v) * (f_z - f_w);
-          _p = (z - v) * q - (z - w) * r;
-          q = 2 * (q - r);
-          
-          if (q > 0)
-            _p = -_p
-          else
-            q = -q;
-          end
-          r = e;
-          e = d;
+      end while ((nb_eval < eval_max) and
+      ((x_right - x_left) > GSL_SQRT_DBL_EPSILON * ( (x_right + x_left) * 0.5 ) + GSL_SQRT_DBL_EPSILON))
+      @x_lower = x_left;
+      @x_upper = x_right;
+      @x_minimum = x_center;
+      @f_lower = f_left;
+      @f_upper = f_right;
+      @f_minimum = f_center;
+      return false;
+
+    end
+    # Start the minimization process
+    # If you want to control manually the process, use brent_iterate
+    def iterate
+      k=0
+      bracketing if @do_bracketing
+      while k<@max_iteration and (@x_lower-@x_upper).abs>@epsilon
+        k+=1
+        result=brent_iterate
+        raise FailedIteration,"Error on iteration" if !result
+        begin 
+          @log << [k, @x_lower, @x_upper, @f_lower, @f_upper, (@x_lower-@x_upper).abs, (@f_lower-@f_upper).abs]
+        rescue =>@e
+          @log << [k, @e.to_s,nil,nil,nil,nil,nil]
         end
-        
-        if (_p.abs < (0.5 * q * r).abs and _p < q * w_lower and _p < q * w_upper)
-          t2 = 2 * tolerance ;
-          
-          d = _p.quo(q);
-          u = z + d;
-          
-          if ((u - x_left) < t2 or (x_right - u) < t2)
-            d = (z < midpoint) ? tolerance : -tolerance ;
-          end
+      end
+      @iterations=k
+      return true
+    end
+    # Generate one iteration.
+    def brent_iterate
+      x_left = @x_lower;
+      x_right = @x_upper;
+
+      z = @x_minimum;
+      d = @e;
+      e = @d;
+      v = @v;
+      w = @w;
+      f_v = @f_v;
+      f_w = @f_w;
+      f_z = @f_minimum;
+
+      golden = 0.3819660;      # golden = (3 - sqrt(5))/2 */
+
+      w_lower = (z - x_left)
+      w_upper = (x_right - z)
+
+      tolerance =  GSL_SQRT_DBL_EPSILON * z.abs
+
+      midpoint = 0.5 * (x_left + x_right)
+      _p,q,r=0,0,0
+      if (e.abs > tolerance)
+
+        # fit parabola */
+
+        r = (z - w) * (f_z - f_v);
+        q = (z - v) * (f_z - f_w);
+        _p = (z - v) * q - (z - w) * r;
+        q = 2 * (q - r);
+
+        if (q > 0)
+          _p = -_p
         else
-          
-          e = (z < midpoint) ? x_right - z : -(z - x_left) ;
-          d = golden * e;
+          q = -q;
         end
-        
-        if ( d.abs >= tolerance)
-          u = z + d;
+        r = e;
+        e = d;
+      end
+
+      if (_p.abs < (0.5 * q * r).abs and _p < q * w_lower and _p < q * w_upper)
+        t2 = 2 * tolerance ;
+
+        d = _p.quo(q);
+        u = z + d;
+
+        if ((u - x_left) < t2 or (x_right - u) < t2)
+          d = (z < midpoint) ? tolerance : -tolerance ;
+        end
+      else
+
+        e = (z < midpoint) ? x_right - z : -(z - x_left) ;
+        d = golden * e;
+      end
+
+      if ( d.abs >= tolerance)
+        u = z + d;
+      else
+        u = z + ((d > 0) ? tolerance : -tolerance) ;
+      end
+
+      @e = e;
+      @d = d;
+
+      f_u=f(u)
+
+      if (f_u <= f_z)
+        if (u < z)
+          @x_upper = z;
+          @f_upper = f_z;
         else
-          u = z + ((d > 0) ? tolerance : -tolerance) ;
+          @x_lower = z;
+          @f_lower = f_z;
         end
-        
-        @e = e;
-        @d = d;
-        
-        f_u=f(u)
-        
-        if (f_u <= f_z)
-          if (u < z)
-            @x_upper = z;
-            @f_upper = f_z;
-          else
-            @x_lower = z;
-            @f_lower = f_z;
-          end          
+        @v = w;
+        @f_v = f_w;
+        @w = z;
+        @f_w = f_z;
+        @x_minimum = u;
+        @f_minimum = f_u;
+        return true;
+      else
+        if (u < z)
+          @x_lower = u;
+          @f_lower = f_u;
+          return true;
+        else
+          @x_upper = u;
+          @f_upper = f_u;
+          return true;
+        end
+
+        if (f_u <= f_w or w == z)
           @v = w;
           @f_v = f_w;
-          @w = z;
-          @f_w = f_z;
-          @x_minimum = u;
-          @f_minimum = f_u;
+          @w = u;
+          @f_w = f_u;
+          return true;
+        elsif f_u <= f_v or v == z or v == w
+          @v = u;
+          @f_v = f_u;
           return true;
-        else
-          if (u < z)          
-            @x_lower = u;
-            @f_lower = f_u;
-            return true;
-          else
-            @x_upper = u;
-            @f_upper = f_u;
-            return true;
-          end
-          
-          if (f_u <= f_w or w == z)
-            @v = w;
-            @f_v = f_w;
-            @w = u;
-            @f_w = f_u;
-            return true;
-          elsif f_u <= f_v or v == z or v == w 
-            @v = u;
-            @f_v = f_u;
-            return true;
-          end
-          
         end
-        return false
-       
+
       end
+      return false
+
     end
   end
+end

data/spec/minimization_unidimensional_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+describe Minimization::Unidimensional, "subclass" do 
+  before(:all) do
+    @p1=rand(100)
+    @p2=rand(100)
+    @func=lambda {|x| (x-@p1)**2+@p2}
+    @funcd=lambda {|x| 2*(x-@p1)}
+    @funcdd=lambda  {|x| 2}
+  end
+  
+  describe Minimization::NewtonRaphson  do
+    before do
+      @min = Minimization::NewtonRaphson.new(-1000,1000, @func,@funcd, @funcdd)
+      @min.iterate
+    end
+    it "#x_minimum be close to expected" do 
+      @min.x_minimum.should be_close(@p1,@min.epsilon)
+    end
+    it "#f_minimum ( f(x)) be close to expected" do 
+      @min.f_minimum.should be_close(@p2,@min.epsilon)
+    end
+    context "#log" do
+      subject {@min.log}
+      it {should be_instance_of Array}
+      it {should respond_to :to_table}
+    end
+  end
+  
+  
+  describe Minimization::GoldenSection  do
+    before do
+      @min = Minimization::GoldenSection.minimize(-1000,1000, &@func)
+    end
+    it "#x_minimum be close to expected" do 
+      @min.x_minimum.should be_close(@p1,@min.epsilon)
+    end
+    it "#f_minimum ( f(x)) be close to expected" do 
+      @min.f_minimum.should be_close(@p2,@min.epsilon)
+    end
+    context "#log" do
+      subject {@min.log}
+      it {should be_instance_of Array}
+      it {should respond_to :to_table}
+    end
+  end
+  describe Minimization::Brent  do
+    before do
+      @min = Minimization::Brent.minimize(-1000,1000, &@func)
+    end
+    it "should x be correct" do 
+      @min.x_minimum.should be_close(@p1,@min.epsilon)
+    end
+    it "should f(x) be correct" do 
+      @min.f_minimum.should be_close(@p2,@min.epsilon)
+    end
+    context "#log" do
+      subject {@min.log}
+      it {should be_instance_of Array}
+      it {should respond_to :to_table}
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+-f s

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'minimization.rb'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end
+
+class String
+  def deindent
+    gsub /^[ \t]*/, ''
+  end
+end

metadata

@@ -1,17 +1,58 @@
 --- !ruby/object:Gem::Specification 
 name: minimization
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Claudio Bustos
 autorequire: 
 bindir: bin
-cert_chain: []
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhjbGJ1
+  c3RvczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+  MB4XDTEwMDMyOTIxMzg1NVoXDTExMDMyOTIxMzg1NVowPzERMA8GA1UEAwwIY2xi
+  dXN0b3MxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+  bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf8JVMGqE7m5kYb+PNN
+  neZv2pcXV5fQCi6xkyG8bi2/SIFy/LyxuvLzEeOxBeaz1Be93bayIUquOIqw3dyw
+  /KXWa31FxuNuvAm6CN8fyeRYX/ou4cw3OIUUnIvB7RMNIu4wbgeM6htV/QEsNLrv
+  at1/mh9JpqawPrcjIOVMj4BIp67vmzJCaUf+S/H2uYtSO09F+YQE3tv85TPeRmqU
+  yjyXyTc/oJiw1cXskUL8UtMWZmrwNLHXuZWWIMzkjiz3UNdhJr/t5ROk8S2WPznl
+  0bMy/PMIlAbqWolRn1zl2VFJ3TaXScbqImY8Wf4g62b/1ZSUlGrtnLNsCYXrWiso
+  UPUCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFGu9
+  rrJ1H64qRmNNu3Jj/Qjvh0u5MA0GCSqGSIb3DQEBBQUAA4IBAQCV0Unka5isrhZk
+  GjqSDqY/6hF+G2pbFcbWUpjmC8NWtAxeC+7NGV3ljd0e1SLfoyBj4gnFtFmY8qX4
+  K02tgSZM0eDV8TpgFpWXzK6LzHvoanuahHLZEtk/+Z885lFene+nHadkem1n9iAB
+  cs96JO9/JfFyuXM27wFAwmfHCmJfPF09R4VvGHRAvb8MGzSVgk2i06OJTqkBTwvv
+  JHJdoyw3+8bw9RJ+jLaNoQ+xu+1pQdS2bb3m7xjZpufml/m8zFCtjYM/7qgkKR8z
+  /ZZt8lCiKfFArppRrZayE2FVsps4X6WwBdrKTMZ0CKSXTRctbEj1BAZ67eoTvBBt
+  rpP0jjs0
+  -----END CERTIFICATE-----
 
-date: 2010-03-19 00:00:00 -03:00
+date: 2010-04-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: text-table
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.2"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.4
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   type: :development
@@ -20,7 +61,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.4.0
+        version: 2.6.0
     version: 
 description: Minimization algorithms on pure Ruby.
 email: 
@@ -41,7 +82,9 @@ files:
 - README.txt
 - Rakefile
 - lib/minimization.rb
-- test/test_minimization.rb
+- spec/minimization_unidimensional_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://ruby-statsample.rubyforge.org/
 licenses: []
@@ -71,5 +114,5 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Minimization algorithms on pure Ruby.
-test_files: 
-- test/test_minimization.rb
+test_files: []
+

metadata.gz.sig

@@ -0,0 +1,3 @@
+b��G4
B	���1њ�h��r5vt���Ԯ�ᗅ�~Nӫ�&
+H,����9! �\m�_�L��]6����i�*��3)�'���&�����~{`-z�,V ���"u"��C�|
�PBpۢ�%5�~Z��<\��f�dC�rj��v^�
+�x�[D��Ù���Pځ�`��"CE������E'4%�!?�O��_��p

data/test/test_minimization.rb

@@ -1,28 +0,0 @@
-$:.unshift(File.dirname(__FILE__)+'/../lib/')
-require "test/unit"
-require "minimization"
-
-class TestMinimization < Test::Unit::TestCase
-  def setup
-    @p1=rand(100)
-    @p2=rand(100)
-    @func=lambda {|x| (x-@p1)**2+@p2}
-  end
-  def test_facade
-    min=Minimization::GoldenSection.minimize(-1000,1000) {|x| (x-@p1)**2+@p2}
-    assert_in_delta(@p1,min.x_minimum, min.epsilon)
-    assert_in_delta(@p2,min.f_minimum, min.epsilon)
-  end
-  def test_golden
-	  min=Minimization::GoldenSection.new(-1000,1000, @func)
-	  min.iterate
-	  assert_in_delta(@p1, min.x_minimum, min.epsilon)
-	  assert_in_delta(@p2, min.f_minimum, min.epsilon)
-	end
-  def test_brent
-	  min=Minimization::Brent.new(-1000,1000, @func)
-	  min.iterate
-	  assert_in_delta(@p1, min.x_minimum, min.epsilon)
-	  assert_in_delta(@p2, min.f_minimum, min.epsilon)
-	end
-end