solver 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Javier Goizueta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,5 @@
+= solver
+
+This numeric solver is an example of the use of Flt.
+
+Copyright (c) 2010 Javier Goizueta. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "solver"
+    gem.summary = %Q{Numeric solver to exercise the Flt library}
+    gem.description = %Q{This numeric solver is an example of the use of Flt}
+    gem.email = "jgoizueta@gmail.com"
+    gem.homepage = "http://github.com/jgoizueta/solver"
+    gem.authors = ["Javier Goizueta"]
+    gem.add_development_dependency "shoulda"
+    gem.add_dependency "flt", ">= 1.3.0"
+    gem.required_ruby_version = '> 1.9.1'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.main = 'README.rdoc'
+  rdoc.title = "solver #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/solver.rb

@@ -0,0 +1,12 @@
+require 'flt/math'
+
+module Flt::Solver
+end
+
+require 'solver/function'
+require 'solver/base'
+require 'solver/secant'
+require 'solver/rfsecant'
+# TODO: Crenshaw/Secant method
+require 'solver/psolver'
+# require 'solver/tvmsolver'

data/lib/solver/base.rb

@@ -0,0 +1,108 @@
+# TODO: add method to check for result: zero or sign reversal / extrema / inflection / asymptote
+# TODO: automatic guesses if single guess or no guesses
+
+# Base class for Fixed-Point Numeric Solvers
+module Flt::Solver
+
+class Base
+
+  # default_guesses: nil for no pre-guess, or one or two guesses (use array for two)
+  def initialize(context, default_guesses, tol, eqn=nil, &blk)
+    @context = context
+    @default_guesses = Array(default_guesses)
+    @x = @default_guesses.first
+    @f = eqn || blk
+    @tol = tol # user-requested tolerance
+    @l_x = nil
+    @fx = nil
+    @l_fx = nil
+    @ok = true
+    @conv = false
+    @max_it = 8192
+  end
+
+  # value of parameters[var] is used as a guess in precedence to the pre-guesses if not nil
+  # use Array for two guesses
+  def root(*guesses)
+    @guess = (guesses + @default_guesses).map{|g| num(g)}
+    @l_x = @x = @guess.first
+    @l_fx = @fx = eval_f(@x)
+    @ok = true
+    @conv = false
+
+    # Minimum tolerance of the numeric type used
+    @numeric_tol = Tolerance(1,:ulps) # Tolerance(@context.epsilon, :floating)
+
+    raise "Invalid parameters" unless validate
+
+    @reason = nil
+    @iteration = 0
+    # TODO: handle NaNs (stop or try to find other guess)
+    while @ok && @iteration < @max_it
+      next_x = step()
+      @l_x = @x
+      @l_fx = @fx
+      @x = next_x
+      @fx = eval_f(@x)
+      # puts "X=#{@x.inspect}[#{@fx.inspect}]"
+      @conv = test_conv() if @ok
+      break if @conv
+      @iteration += 1
+    end
+    @ok = false if @iteration >= @max_it # TODO: set reason
+    @x
+
+  end
+
+  def value
+    @fx
+  end
+
+  attr_reader :reason, :iteration
+
+  protected
+
+  def eval_f(x)
+    @context.math x, &@f
+  end
+
+  def num(v)
+    @context.Num(v)
+  end
+
+  def zero?
+    @tol.zero?(@fx)
+  end
+
+  def test_conv
+    #@tol.eq?(@x, @l_x) || @tol.eq?(@fx, @l_fx) || zero?
+    # puts "test #{@x} #{@fx}"
+    # if @tol.eq?(@fx, @l_fx) && !(@tol.eq?(@x, @l_x) || zero?)
+    #   puts "---> v=#{@tol.relative_to_many(:max, @fx, @l_fx)} #{@fx} #{@l_fx} x=#{@x}"
+    # end
+
+    # zero? || @x==@l_x || @fx == @l_fx
+    #@numeric_tol.eq?(@x, @l_x) || zero? || @numeric_tol.eq?(@fx, @l_fx)
+
+    # TODO : use symbols for reason
+    if zero?
+      @reason = "Zero found #{@fx.inspect} @ #{@x.inspect}"
+    elsif @numeric_tol.eq?(@x, @l_x)
+      @reason = "Critical point" # Sign Reversal (@fx != @l_fx) or vertical tangent / asymptote
+    elsif @numeric_tol.eq?(@fx, @l_fx)
+      @reason = "Flat" # flat function
+    end
+    !@reason.nil?
+
+    # TODO: try to get out of flat; if @x==@l_x try to find other point?;
+
+    #zero?
+  end
+
+  def validate
+    true
+  end
+
+end # Base
+
+end # Flt::Solve

data/lib/solver/function.rb

@@ -0,0 +1,99 @@
+# Some utilities to work with functions defined by blocks or lambdas, and defining parameter values with
+# hashes without the need to redundantly define the names of the parameters.
+# Currently works only with Ruby >= 1.9.2 (it uses Proc#parameters).
+# 
+# Examples:
+#   f = Function.with_named_parameters(){|x,y,z| puts "x=#{x} y=#{y} z=#{z}"}
+#   f[x:100, y:200, z:300] # => "x=100 y=200 z=300"
+#   f = Function.bind(:x=>1000,:z=>2000){|x,y,z| puts "x=#{x} y=#{y} z=#{z}"}
+#   f[5000] # => "x=1000 y=5000 z=2000"
+#   f[6000] # => "x=1000 y=6000 z=2000"
+# Or, with Function[] syntax:
+#   f = lambda{|x,y,z| puts "x=#{x} y=#{y} z=#{z}"}
+#   Function[f][x:100, y:200, z:300] # => "x=100 y=200 z=300"
+#   f = Function[f, :x=>1000, :z=>2000]
+#   f[5000] # => "x=1000 y=5000 z=2000"
+#   f[6000] # => "x=1000 y=6000 z=2000"
+#
+module Flt::Solver::Function
+
+  # Names of the parameters of a functor (block, Proc, etc.) (including optional and 'rest' parameters)
+  #   Function.parameters(lambda{|a,b,c|...}) => [:a, :b, :c]
+  #   Function.parameters{|a,b,c|...} => [:a, :b, :c]
+  # Note that a block access through a &block variable is converted with Proc.new and this makes
+  # all arguments optional (or :rest). On the other hand if a lambda is passed as a block it retains the
+  # :req/:opt/attributes of its arguments.
+  def self.parameters(fun=nil, &blk)
+    fun = get(:parameters, fun, blk)  
+    fun.parameters.select{|p,cls| cls!=:rest}.map{|p| p.last} # requires Ruby >= 1.9.2
+  end
+  
+  # Returns a function by binding some of the arguments of a functor to values passed in a hash 
+  #   Function.bind(f=lambda{|a,b,c|...}, :a=>1,:c=>2) => lambda{|x| f[1,x,2]}
+  #   Function.bind(:a=>1, :c=>2){|a,b,c|...}          => lambda{|x| f[1,x,2]}
+  def self.bind(*args, &blk)
+    fun = args.shift unless args.first.kind_of?(Hash)
+    params = args.shift || {}
+    fun = get(:bind, fun, blk)
+    fun_parameters = parameters(fun)
+    fun_args = fun_parameters - params.keys
+    lambda do |*args|
+      fun[*params.merge(Hash[fun_args.zip(args)]).values_at(*fun_parameters)]
+    end
+  end
+
+  # Returns a function that takes parameters from a hash
+  #   Function.with_named_parameters(f=lambda{|a,b,c|...}) =>  lambda{|params| f[params[:a], params[:b], params[:c]]}
+  #   Function.with_named_parameters{|a,b,c|...} =>  lambda{|params| f[params[:a], params[:b], params[:c]]}
+  def self.with_named_parameters(*args, &blk)    
+    fun = args.shift unless args.first.kind_of?(Hash)
+    fun = get(:with_named_parameters, fun, blk)
+    lambda do |parameters|
+      fun[*parameters.values_at(*parameters(fun))]
+    end
+  end
+  
+  # Shortcut for Function.bind or Function.with_named_parameters
+  #   Function[f=lambda{|a,b,c|...}, :a=>1,:c=>2] => lambda{|x| f[1,x,2]}
+  #   Function[:a=>1, :c=>2, &lambda{|a,b,c|...}]          => lambda{|x| f[1,x,2]}
+  #   Function[f=lambda{|a,b,c|...}] =>  lambda{|params| f[params[:a], params[:b], params[:c]]}
+  #   Function[&lambda{|a,b,c|...}]         =>  lambda{|params| f[params[:a], params[:b], params[:c]]}
+  # Note that this syntax is not admitted by Ruby:
+  #   Function[:a=>1, :c=>2]{|a,b,c|...}
+  #   Function[]{|a,b,c|...}
+  def self.[](*args, &blk)
+    fun = args.shift unless args.first.kind_of?(Hash)
+    parameters = args.shift
+    if parameters.nil?
+      with_named_parameters(fun, &blk)
+    else
+      bind(fun, parameters, &blk)
+    end
+  end
+
+  # # alternative implementation
+  # def self.bind(fun, parameters, &blk)
+  #   fun = get(:bind, fun, blk)
+  #   fun_parameters = parameters(fun)
+  #   fun_args = (fun_parameters - parameters.keys).map{|arg| fun_parameters.index(arg)}
+  #   parameters = fun_parameters.map{|p| parameters[p]}
+  #   lambda do |*args|
+  #     fun_args.each_with_index do |arg_pos, i|
+  #       parameters[arg_pos] = args[i]
+  #     end
+  #     fun[*parameters]
+  #   end
+  # end
+
+
+  class <<self
+    private
+      def get(mth, fun, blk)
+        raise "Must pass either a proc/lambda or a block to #{mth}" unless fun || blk
+        raise "Must pass only one of a proc/lambda or a block to #{mth}" if fun && blk
+        fun || blk
+      end
+   end
+
+end
+

data/lib/solver/psolver.rb

@@ -0,0 +1,70 @@
+module Flt::Solver
+  
+  # Solver with equation parameters passed in a hash
+  # 
+  # Example: a simple TVM (Time Value of Money) solver
+  #
+  #   # ln(x+1)
+  #   def lnp1(x)
+  #     v = x + 1
+  #     (v == 1) ? x : (x*ln(v) / (v - 1))
+  #   end
+  # 
+  #   tvm = Flt::Solver::PSolver.new(Float.context, Flt.Tolerance(3,:decimals)) do |m, t, m0, pmt, i, p|
+  #     i /= 100
+  #     i /= p
+  #     n = -t
+  #     k = exp(lnp1(i)*n) # (i+1)**n
+  #     # Equation: -m*k = m0 + pmt*(1-k)/i
+  #     m0 + pmt*(Num(1)-k)/i + m*k
+  #   end
+  #   tvm.default_guesses = 1,2
+  #   sol = tvm.root :pmt, :t=>240, :m0=>10000, :m=>0, :i=>3, :p=>12 #, :pmt=>[1,2]
+  #   puts sol.inspect # => -55.45975978539105
+  #
+  class PSolver
+    
+    def initialize(context, tol, solver_class=nil, &blk)
+
+      @solver_class = solver_class || RFSecantSolver
+      @eqn = blk
+      @vars = Function.parameters(@eqn)
+      # alternatively, we could keep @eqn = Function[@eqn] and dispense with @vars
+
+      @default_guesses = nil
+
+      @context = context
+      @tol = tol
+      @solver = nil
+
+    end
+
+    def default_guesses=(*g)
+      @default_guesses = g
+      @solver = nil
+    end
+
+    def root(var, parameters)
+      init_solver
+      @var = var
+      @parameters = parameters
+      guesses = Array(parameters[var])
+      @solver.root *guesses
+    end
+
+    def equation_value(v)
+      values = @parameters.merge(@var=>v)
+      #@context.math(*values.values_at(*@vars).map{|v| @context.Num(v)}, &@eqn)
+      @context.math(*@vars.map{|v| @context.Num(values[v])}, &@eqn)
+      # equivalent to: @context.math(values, &Function[@eqn]) # which doesn't need @vars
+    end
+
+    private
+    def init_solver
+      this = self
+      @solver ||= @solver_class.new(@context, @default_guesses, @tol){|v| this.equation_value(v)}
+    end
+
+  end
+
+end # Flt::PSolver

data/lib/solver/rfsecant.rb

@@ -0,0 +1,84 @@
+module Flt::Solver
+  
+  # Regula-Falsi/Secant method solver
+  # Secant is used if no bracketing is available
+  # 
+  # Example of use:
+  #   require 'solver'
+  #   include Flt
+  #   solver = Solver::SecantSolver.new(Float.context, [0.0, 100.0], Tolerance(3, :decimals)) do |x|
+  #     2*x+11.0
+  #   end
+  #   puts solver.root
+  #   # with a guess:
+  #   puts solver.root(5.0)
+  #
+  #   solver = SecantSolver.new(Float.context, [0.0, 10.0], Tolerance(3, :decimals)) do |x|
+  #     y = 2
+  #     y*exp(x)-10
+  #   end
+  #   puts solver.root
+  #
+  class RFSecantSolver < Base
+
+    def initialize(context, default_guesses, tol, eqn=nil, &blk)
+      super context, default_guesses, tol, eqn, &blk
+      @a = @b = @fa = @fb = nil
+      @bracketing = false
+      @half = num(Rational(1,2))
+    end
+
+    def step
+      return @guess[1] if @iteration == 0
+      regula_falsi = false
+      dy = @fx - @l_fx
+
+      if @tol.zero?(dy)
+        if @bracketing
+          regula_falsi = true
+        else
+          @ok = false
+          return @x
+        end
+      end
+
+      if !regula_falsi
+        next_x = @x - ((@x - @l_x)*@fx)/dy
+        regula_falsi = true if @bracketing && (next_x < @a || next_x > @b)
+      end
+      next_x = @b - (@b - @a)*@fb/(@fb - @fa) if regula_falsi
+      next_fx = eval_f(next_x)
+
+      if @bracketing
+        if @context.sign(@fa) == @context.sign(next_fx)
+          @a = next_x
+          @fa = next_fx
+        else
+          @b = next_x
+          @fb = next_fx
+        end
+      else
+        if @context.sign(next_fx) != @context.sign(@fx)
+          @a, @b = @x, next_x
+          @a, @b = @b, @a if @a > @b
+          @fa = eval_f(@a)
+          @fb = eval_f(@b)
+          @bracketing = true
+        end
+      end
+      # puts "br: #{@bracketing} r-f: #{regula_falsi} x:#{@x}[#{@fx}] l_x:#{@l_x}[#{@l_fx}] #{next_x}"
+      next_x
+    end
+
+    def validate
+      @guess = @guess.uniq
+      if @guess.size < 2
+        return false if @guess.empty?
+        @guess << (@guess.first + 1)
+      end
+      true
+    end
+
+  end  # RFSecantSolver
+  
+end # Flt::Solver

data/lib/solver/secant.rb

@@ -0,0 +1,84 @@
+module Flt::Solver
+  
+  # Secant method solver
+  # Bisect method is used is bracketing found (sign(f(a)) != sign(f(b)))
+  # 
+  # Example of use:
+  #   require 'solver'
+  #   require 'flt/tolerance'
+  #   include Flt
+  #   solver = Solver::SecantSolver.new(Float.context, [0.0, 100.0], Tolerance(3, :decimals)) do |x|
+  #     2*x+11.0
+  #   end
+  #   puts solver.root
+  #   # with a guess:
+  #   puts solver.root(5.0)
+  #
+  #   solver = SecantSolver.new(Float.context, [0.0, 10.0], Tolerance(3, :decimals)) do |x|
+  #     y = 2
+  #     y*exp(x)-10
+  #   end
+  #   puts solver.root
+  #
+  class SecantSolver < Base
+
+    def initialize(context, default_guesses, tol, eqn=nil, &blk)
+      super context, default_guesses, tol, eqn, &blk
+      @a = @b = @fa = @fb = nil
+      @bracketing = false
+      @half = num(Rational(1,2))
+    end
+
+    def step
+      return @guess[1] if @iteration == 0
+      bisect = false
+      dy = @fx - @l_fx
+
+      if @tol.zero?(dy)
+        if @bracketing
+          bisect = true
+        else
+          @ok = false
+          return @x
+        end
+      end
+
+      if !bisect
+        next_x = @x - ((@x - @l_x)*@fx)/dy
+        bisect = true if @bracketing && (next_x < @a || next_x > @b)
+      end
+      next_x = (@a + @b)*@half if bisect
+      next_fx = eval_f(next_x)
+
+      if @bracketing
+        if @context.sign(@fa) == @context.sign(next_fx)
+          @a = next_x
+          @fa = next_fx
+        else
+          @b = next_x
+          @fb = next_fx
+        end
+      else
+        if @context.sign(next_fx) != @context.sign(@fx)
+          @a, @b = @x, next_x
+          @a, @b = @b, @a if @a > @b
+          @fa = eval_f(@a)
+          @fb = eval_f(@b)
+          @bracketing = true
+        end
+      end
+      next_x
+    end
+
+    def validate
+      @guess = @guess.uniq
+      if @guess.size < 2
+        return false if @guess.empty?
+        @guess << (@guess.first + 1)
+      end
+      true
+    end
+
+  end # SecantSolver
+  
+end # Flt::Solver

data/solver.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{solver}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Javier Goizueta"]
+  s.date = %q{2010-06-29}
+  s.description = %q{This numeric solver is an example of the use of Flt}
+  s.email = %q{jgoizueta@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/solver.rb",
+     "lib/solver/base.rb",
+     "lib/solver/function.rb",
+     "lib/solver/psolver.rb",
+     "lib/solver/rfsecant.rb",
+     "lib/solver/secant.rb",
+     "solver.gemspec",
+     "test/helper.rb",
+     "test/test_function.rb",
+     "test/test_psolver.rb",
+     "test/test_rfsecant.rb",
+     "test/test_secant.rb"
+  ]
+  s.homepage = %q{http://github.com/jgoizueta/solver}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new("> 1.9.1")
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Numeric solver to exercise the Flt library}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_function.rb",
+     "test/test_psolver.rb",
+     "test/test_rfsecant.rb",
+     "test/test_secant.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_runtime_dependency(%q<flt>, [">= 1.3.0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<flt>, [">= 1.3.0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<flt>, [">= 1.3.0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'solver'
+
+class Test::Unit::TestCase
+end

data/test/test_function.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class TestFunction < Test::Unit::TestCase
+  
+  should "convert function to use a hash for parameters" do
+    f = Flt::Solver::Function.with_named_parameters(){|x,y,z| "x=#{x} y=#{y} z=#{z}"}
+    assert_equal "x=100 y=200 z=300", f[:x=>100, :y=>200, :z=>300]
+    assert_equal "x=1 y=2 z=3", f[:x=>1, :y=>2, :z=>3]
+    
+    f = lambda{|x,y,z| "x=#{x} y=#{y} z=#{z}"}
+    g = Flt::Solver::Function[f]
+    assert_equal "x=100 y=200 z=300", g[:x=>100, :y=>200, :z=>300]
+  end
+  
+  should "bind some of a function's parameters" do
+    f = Flt::Solver::Function.bind(:x=>1000,:z=>2000){|x,y,z| "x=#{x} y=#{y} z=#{z}"}
+    assert_equal "x=1000 y=5000 z=2000", f[5000]
+    assert_equal "x=1000 y=6000 z=2000", f[6000]
+    
+    f = lambda{|x,y,z| "x=#{x} y=#{y} z=#{z}"}
+    f = Flt::Solver::Function[f, :x=>1000, :z=>2000]
+    assert_equal "x=1000 y=5000 z=2000", f[5000]
+    assert_equal "x=1000 y=6000 z=2000", f[6000]
+  end
+  
+end

data/test/test_psolver.rb

@@ -0,0 +1,55 @@
+require 'helper'
+require 'flt/float'
+require 'flt/tolerance'
+
+include Flt
+
+class TestPSolver < Test::Unit::TestCase
+  
+  context "The PSolver class" do
+    
+    context "using Float arithmetic" do
+    
+      setup do
+        @context = Float.context
+        @tolerance = Flt.Tolerance(3,:decimals)
+        @delta = 5E-4
+      end
+      
+      context "with a TVM-equation definition" do
+      
+        setup do
+          @context.class.class_eval do
+            define_method :lnp1 do |x|
+              v = x + 1
+              (v == 1) ? x : (x*ln(v) / (v - 1))
+            end
+          end
+          @tvm = Flt::Solver::PSolver.new(@context, @tolerance) do |m, t, m0, pmt, i, p|
+            i /= 100
+            i /= p
+            n = -t
+            k = exp(lnp1(i)*n) # (i+1)**n
+            # Equation: -m*k = m0 + pmt*(1-k)/i
+            m0 + pmt*(Num(1)-k)/i + m*k
+          end
+          @tvm.default_guesses = 1,2
+        end
+      
+        should "solve for :pmt correctly" do
+          solution = @tvm.root :pmt, :t=>240, :m0=>10000, :m=>0, :i=>3, :p=>12 #, :pmt=>[1,2]
+          assert_in_delta @context.Num('-55.45975978539105'), solution, @delta
+        end
+
+        should "solve for :t correctly" do
+          solution = @tvm.root :t, :pmt=>@context.Num('-55.45975978539105'), :m0=>10000, :m=>0, :i=>3, :p=>12 #, :pmt=>[1,2]
+          assert_in_delta 240, solution, @delta
+        end
+        
+      end
+
+    end
+    
+  end
+  
+end

data/test/test_rfsecant.rb

@@ -0,0 +1,66 @@
+require 'helper'
+require 'flt/float'
+require 'flt/tolerance'
+
+include Flt
+
+class TestRFSecant < Test::Unit::TestCase
+  
+  context "The Regula-Falsi/Secant Solver" do
+  
+    context "using Float arithmetic" do
+      
+      setup do
+        @context = Float.context
+        @tolerance = Flt.Tolerance(3,:decimals)
+        @delta = 5E-4
+      end
+  
+      should "solve equations" do
+        solver = Flt::Solver::RFSecantSolver.new(@context, [0.0, 100.0], @tolerance) do |x|
+          2*x+11.0
+        end
+        assert_in_delta -5.5, solver.root, @delta
+        assert_in_delta -5.5, solver.root(5.0), @delta
+        assert_in_delta -5.5, solver.root(6.0), @delta
+  
+        solver = Flt::Solver::SecantSolver.new(@context, [0.0, 10.0], @tolerance) do |x|
+          y = 2
+          y*exp(x)-10
+        end
+        assert_in_delta 1.6094389956808506, solver.root, @delta
+        assert_in_delta 1.6094389956808506, solver.root(1.0), @delta
+        assert_in_delta 1.6094389956808506, solver.root(2.0), @delta
+      end
+    end
+
+    context "using DecNum arithmetic" do
+      
+      setup do
+        @context = Flt::DecNum.context(:precision=>12)
+        @tolerance = Flt.Tolerance(5,:decimals)
+        @delta = @tolerance.value
+      end
+  
+      should "solve equations" do
+        solver = Flt::Solver::RFSecantSolver.new(@context, [0, 100].map{|v| @context.Num(v)}, @tolerance) do |x|
+          2*x+11
+        end
+        assert_in_delta @context.Num('-5.5'), solver.root, @delta
+        assert_in_delta @context.Num('-5.5'), solver.root(5), @delta
+        assert_in_delta @context.Num('-5.5'), solver.root(6), @delta
+  
+        solver = Flt::Solver::SecantSolver.new(@context, [0, 10].map{|v| @context.Num(v)}, @tolerance) do |x|
+          y = 2
+          y*exp(x)-10
+        end
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root, @delta
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root(1), @delta
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root(2), @delta
+      end
+      
+    end
+    
+  end
+  
+end

data/test/test_secant.rb

@@ -0,0 +1,66 @@
+require 'helper'
+require 'flt/float'
+require 'flt/tolerance'
+
+include Flt
+
+class TestSecant < Test::Unit::TestCase
+  
+  context "The Secant Solver" do
+  
+    context "using Float arithmetic" do
+      
+      setup do
+        @context = Float.context
+        @tolerance = Flt.Tolerance(3,:decimals)
+        @delta = 5E-4
+      end
+  
+      should "solve equations" do
+        solver = Flt::Solver::SecantSolver.new(@context, [0.0, 100.0], @tolerance) do |x|
+          2*x+11.0
+        end
+        assert_in_delta -5.5, solver.root, @delta
+        assert_in_delta -5.5, solver.root(5.0), @delta
+        assert_in_delta -5.5, solver.root(6.0), @delta
+  
+        solver = Flt::Solver::SecantSolver.new(@context, [0.0, 10.0], @tolerance) do |x|
+          y = 2
+          y*exp(x)-10
+        end
+        assert_in_delta 1.6094389956808506, solver.root, @delta
+        assert_in_delta 1.6094389956808506, solver.root(1.0), @delta
+        assert_in_delta 1.6094389956808506, solver.root(2.0), @delta
+      end
+    end
+
+    context "using DecNum arithmetic" do
+      
+      setup do
+        @context = Flt::DecNum.context(:precision=>12)
+        @tolerance = Flt.Tolerance(5,:decimals)
+        @delta = @tolerance.value
+      end
+  
+      should "solve equations" do
+        solver = Flt::Solver::SecantSolver.new(@context, [0, 100].map{|v| @context.Num(v)}, @tolerance) do |x|
+          2*x+11
+        end
+        assert_in_delta @context.Num('-5.5'), solver.root, @delta
+        assert_in_delta @context.Num('-5.5'), solver.root(5), @delta
+        assert_in_delta @context.Num('-5.5'), solver.root(6), @delta
+  
+        solver = Flt::Solver::SecantSolver.new(@context, [0, 10].map{|v| @context.Num(v)}, @tolerance) do |x|
+          y = 2
+          y*exp(x)-10
+        end
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root, @delta
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root(1), @delta
+        assert_in_delta @context.Num('1.6094389956808506'), solver.root(2), @delta
+      end
+      
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: solver
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: flt
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :runtime
+  version_requirements: *id002
+description: This numeric solver is an example of the use of Flt
+email: jgoizueta@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/solver.rb
+- lib/solver/base.rb
+- lib/solver/function.rb
+- lib/solver/psolver.rb
+- lib/solver/rfsecant.rb
+- lib/solver/secant.rb
+- solver.gemspec
+- test/helper.rb
+- test/test_function.rb
+- test/test_psolver.rb
+- test/test_rfsecant.rb
+- test/test_secant.rb
+has_rdoc: true
+homepage: http://github.com/jgoizueta/solver
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 1
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Numeric solver to exercise the Flt library
+test_files: 
+- test/helper.rb
+- test/test_function.rb
+- test/test_psolver.rb
+- test/test_rfsecant.rb
+- test/test_secant.rb