finance 0.1.1 → 0.2.0

data/README

@@ -12,7 +12,8 @@ _finance_ - a library for financial calculations in Ruby.
 
 == AMORTIZATION
 
-You are interested in borrowing $250,000 under a 30 year, fixed-rate loan with a 4.25% APR.
+You are interested in borrowing $250,000 under a 30 year, fixed-rate
+loan with a 4.25% APR.
 
   >> rate = Rate.new(0.0425, :apr, :duration => 30.years)
   >> amortization = 250000.amortize(rate)
@@ -37,11 +38,74 @@ How much interest in the first six months?
   >> amortization.interest[0,6].sum
   => DecNum('5294.62')
 
+If your loan has an adjustable rate, no problem.  You can pass an
+arbitrary number of rates, and they will be used in the amortization.
+For example, we can look at an amortization of $250000, where the APR
+starts at 4.25%, and increases by 1% every five years.
+
+  >> values = %w{ 0.0425 0.0525 0.0625 0.0725 0.0825 0.0925 }
+  >> rates = values.collect { |value| Rate.new( value, :apr, :duration = 5.years ) }
+  >> arm = Amortization.new(250000, *rates)
+
+Since we are looking at an ARM, there is no longer a single "payment" value.
+
+  >> arm.payment
+  => nil
+
+But we can look at the different payments over time.
+
+  >> arm.payments.uniq
+  => [DecNum('-1229.85'), DecNum('-1360.41'), DecNum('-1475.65'), DecNum('-1571.07'), DecNum('-1641.34'), ... snipped ... ]
+
+The other methods previously discussed can be accessed in the same way:
+
+  >> arm.interest.sum
+  => DecNum('287515.45')
+  >> arm.payments.sum
+  => DecNum('-537515.45')
+
+Last, but not least, you may pass a block when creating an Amortization
+which returns a modified monthly payment.  For example, to increase your
+payment by $150, do:
+
+  >> rate = Rate.new(0.0425, :apr, :duration => 30.years)
+  >> extra_payments = 250000.amortize(rate){ |period| period.payment - 150 }
+
+Disregarding the block, we have used the same parameters as the first
+example.  Notice the difference in the results:
+
+  >> amortization.payments.sum
+  => DecNum('-442745.98')
+  >> extra_payments.payments.sum
+  => DecNum('-400566.24')
+  >> amortization.interest.sum
+  => DecNum('192745.98')
+  >> extra_payments.interest.sum
+  => DecNum('150566.24')
+
+*Note*: you are _not_ allowed to modify a payment to pay _less_ than the
+normally calculated payment.
+
+You can also increase your payment to a specific amount:
+
+  >> extra_payments_2 = 250000.amortize(rate){ -1500 }
+
 = ABOUT
 
-I began developing _finance_ while writing a Ruby script for analyzing
-mortgages.  I couldn't find an existing resource for these tools, I am
-hoping to save other folks some time by releasing what I have as a gem.
+I started developing _finance_ while analyzing mortgages as a personal
+project.  Spreadsheets have convenient formulas for doing this type of
+work, until you want to do something semi-complex (like ARMs or extra
+payments), at which point you need to create your own amortization
+table.  I thought I could create a better interface for this type of
+work in Ruby, and since I couldn't find an existing resource for these
+tools, I am hoping to save other folks some time by releasing what I
+have as a gem.
+
+More broadly, I believe there are many calculations that are necessary
+for the effective management of personal finances, but are difficult
+(or impossible) to do with spreadsheets or other existing open source
+tools.  My hope is that the _finance_ library will grow to provide a set
+of open, tested tools to fill this gap.
 
 If you have used _finance_ and find it useful, I would enjoy hearing
 about it!
@@ -50,16 +114,12 @@ about it!
 
 Currently implemented features include:
 
+* Uses the {http://flt.rubyforge.org/ flt} library to ensure precision decimal arithmetic in all calculations.
 * Fixed-rate mortgage amortization (30/360).
 * Interest rates
 * Various cash flow computations, such as NPV, IRR, and sum.
-
-Planned features include:
-
 * Adjustable rate mortgage amortization.
 * Payment modifications (i.e., how does paying an additional $75 per month affect the amortization?)
-* Balloon payments.
-* Support for amortization methods other than 30/360.
 
 = RESOURCES
 
@@ -69,6 +129,9 @@ This gem and related documentation is available through
 Source code and bug tracking is available via
 {http://github.com/wkranec/finance github}.
 
+Additional documentation is available on the
+{https://github.com/wkranec/finance/wiki wiki}.
+
 = COPYRIGHT
 
 This library is released under the terms of the LGPL license.

data/lib/amortization.rb

@@ -1,91 +1,160 @@
+require 'rubygems'
 require 'cashflows'
+require 'flt'
 
 class Period
-	attr_accessor :payment
-	attr_accessor :principal
-	attr_accessor :rate
-
-	# Return the remaining balance at the end of the period.
-	def balance
-		@principal + @payment + self.interest
-	end
-
-	def initialize(principal, rate, payment)
-		@principal = principal
-		@rate = rate
-		@payment = payment
-	end
-
-	# Return the interest charged for the period.
-	def interest
-		(@principal * @rate).round(2)
-	end
+  attr_accessor :payment
+  attr_accessor :principal
+  attr_accessor :rate
+
+  def additional_payment
+    @payment-@original_payment
+  end
+
+  # Return the remaining balance at the end of the period.
+  def balance
+    @principal + @payment + self.interest
+  end
+
+  def initialize(principal, rate, payment)
+    @principal = principal
+    @rate = rate
+    @payment = payment
+    @original_payment = payment
+  end
+
+  # Return the interest charged for the period.
+  def interest
+    (@principal * @rate).round(2)
+  end
+
+  def modify_payment(&modifier)
+    value = modifier.call(self)
+    
+    # There's a chance that the block does not return a decimal.
+    unless value.class == Flt::DecNum
+      value = Flt::DecNum value.to_s
+    end
+
+    self.payment = value
+  end
+
+  def payment=(value)
+    total = @principal + self.interest
+    if value.abs > total
+      @payment = -total
+    else
+      @payment = value
+    end
+  end
 end
 
 class Amortization
-	attr_accessor :balance
-	attr_accessor :duration
-	attr_accessor :payment
-	attr_accessor :periods
-	attr_accessor :principal
-	attr_accessor :rate
-
-	def compute(balance, rate)
-		duration = @duration - @periods.length
-		@payment = Amortization.payment balance, rate.monthly, duration
-
-		rate.duration.times do
-			if @payment > @balance
-				@payment = @balance
-			end
-
-			period = Period.new(@balance, rate.monthly, @payment)
-			@periods << period
-			@balance = period.balance
-
-			if @balance.zero?
-				break
-			end
-		end
-	end
-
-	def initialize(principal, rate)
-		@principal = principal
-		@balance   = principal
-		@rate      = rate
-		@duration  = rate.duration
-		@periods   = []
-
-		compute(@balance, @rate)
-
-		# Add any remaining balance due to rounding error to the last payment.
-		unless @balance.zero?
-			@periods[-1].payment -= @balance
-			@balance = 0
-		end
-	end
-
-	def inspect
-		"Amortization.new(#{@principal}, #{@rate}"
-	end
-
-	def interest
-		@periods.collect { |period| period.interest }
-	end
+  attr_accessor :balance
+  attr_accessor :block
+  attr_accessor :rate_duration
+  attr_accessor :payment
+  attr_accessor :periods
+  attr_accessor :principal
+  attr_accessor :rates
+
+  def ==(amortization)
+    self.principal == amortization.principal and self.rates == amortization.rates and self.payments == amortization.payments
+  end
+
+  def additional_payments
+    @periods.collect{ |period| period.additional_payment }
+  end
+
+  def amortize(rate)
+    # For the purposes of calculating a payment, the relevant time
+    # period is the remaining number of periods in the loan, _not_ the
+    # duration of the rate itself.
+    duration = @rate_duration - @periods.length
+    payment = Amortization.payment @balance, rate.monthly, duration
+
+    rate.duration.times do
+      # Do this first in case the balance is zero already.
+      if @balance.zero?
+        break
+      end
+
+      period = Period.new(@balance, rate.monthly, payment)
+
+      if @block
+        period.modify_payment(&@block)
+      end
+      
+      @periods << period
+      @balance = period.balance
+    end
+
+    if @rates.length == 1
+      @payment = self.payments[0]
+    else
+      @payment = nil
+    end
+  end
+
+  # Compute the amortization of the principal.
+  def compute
+    @balance = @principal
+    @periods = []
+
+    @rates.each do |rate|
+      amortize(rate)
+    end
+
+    # Add any remaining balance due to rounding error to the last payment.
+    unless @balance.zero?
+      @periods[-1].payment -= @balance
+      @balance = 0
+    end
+  end
+
+  def duration
+    @periods.length
+  end
+
+  def initialize(principal, *rates, &block)
+    @principal = principal
+    @rates     = rates
+    @rate_duration  = (rates.collect { |r| r.duration }).sum
+    @block     = block
+
+    compute
+  end
+
+  def inspect
+    "Amortization.new(#{@principal}"
+  end
+
+  # Return an Array with the amount of interest charged in each period.
+  def interest
+    @periods.collect { |period| period.interest }
+  end
 
   # Return the periodic payment due on a loan, based on the
   #{http://en.wikipedia.org/wiki/Amortization_calculator amortization process}.
-	def Amortization.payment(balance, rate, periods)
-		-(balance * (rate + (rate / ((1 + rate) ** periods - 1)))).round(2)
-	end
-
-	def payments
-		@periods.collect { |period| period.payment }
-	end
+  def Amortization.payment(balance, rate, periods)
+    -(balance * (rate + (rate / ((1 + rate) ** periods - 1)))).round(2)
+  end
+
+  # Return an array with the payment amount for each period.
+  def payments
+    @periods.collect { |period| period.payment }
+  end
+
+  # "Pretty print" a text amortization table.
+  def pprint
+    @periods.each_with_index do |p, i|
+      puts "%03d  $%9s  %8s  $%7s  $%7s  $%9s" % [i, p.principal, p.rate, p.payment, p.interest, p.balance]
+    end
+  end
 end
 
 class Numeric
-	def amortize(rate)
-		Amortization.new(self, rate)
-	end
+  def amortize(rate, &block)
+    amortization = Amortization.new(self, rate, &block)
+  end
 end

data/lib/cashflows.rb

@@ -1,33 +1,33 @@
 module Cashflow
-	# Return the {http://en.wikipedia.org/wiki/Internal_rate_of_return
-	# internal rate of return} for a given sequence of cashflows.
-	def irr(iterations=100)
-		rate = 1.0
-		investment = self[0]
-		for i in 1..iterations+1
-			rate = rate * (1 - self.npv(rate) / investment)
-		end
-		rate
-	end
+  # Return the {http://en.wikipedia.org/wiki/Internal_rate_of_return
+  # internal rate of return} for a given sequence of cashflows.
+  def irr(iterations=100)
+    rate = 1.0
+    investment = self[0]
+    for i in 1..iterations+1
+      rate = rate * (1 - self.npv(rate) / investment)
+    end
+    rate
+  end
 
-	# Return the {http://en.wikipedia.org/wiki/Net_present_value net present value} of a sequence of cash flows given
-	# the discount rate _rate_.
-	def npv(rate)
-		total = 0.0
-		self.each_with_index do |cashflow, index|
-			total = total + cashflow / (1+rate) ** index
-		end
-		total
-	end
+  # Return the {http://en.wikipedia.org/wiki/Net_present_value net present value} of a sequence of cash flows given
+  # the discount rate _rate_.
+  def npv(rate)
+    total = 0.0
+    self.each_with_index do |cashflow, index|
+      total = total + cashflow / (1+rate) ** index
+    end
+    total
+  end
 
-	def sum
-		self.inject(:+)
-	end
+  def sum
+    self.inject(:+)
+  end
 
-	def xirr
-	end
+  def xirr
+  end
 end
 
 class Array
-	include Cashflow
+  include Cashflow
 end

data/lib/finance.rb

@@ -12,52 +12,52 @@ require 'timespan'
 #  * *rate* represents the interest rate _per period_.
 module Finance
 
-	def Finance.payments(principal, rates)
-		p_total = rates.inject(0) { |sum, n| sum + n[0] }
-		p_current = 0
-		payments = []
-
-		rates.each do |periods, rate|
-			payment = Finance.pmt(principal, rate, p_total-p_current)
-
-			begin
-				payment = payment.round(2)
-			rescue ArgumentError
-				payment = (payment * 100.0).round / 100.0
-			end
-
-			if block_given?
-				payment = yield(payment)
-			end
-
-			periods.times do
-				interest = principal * rate
-
-				if payment > principal + interest
-					payment = principal + interest
-				end
-
-				principal = principal + interest - payment
-
-				begin
-					principal = principal.round(2)
-				rescue ArgumentError
-					principal = (principal * 100.0).round / 100.0
-				end
-
-				payments << payment
-				break if principal == 0
-				
-				p_current = p_current + 1
-			end
-		end
-
-		payments
-	end
-
-	# Return the number of periods needed to pay off a loan with the
-	# given payment.
-	def Finance.nper(payment, rate, principal)
-		-(Math.log(1-((principal/payment)*rate))) / Math.log(1+rate)
-	end
+  def Finance.payments(principal, rates)
+    p_total = rates.inject(0) { |sum, n| sum + n[0] }
+    p_current = 0
+    payments = []
+
+    rates.each do |periods, rate|
+      payment = Finance.pmt(principal, rate, p_total-p_current)
+
+      begin
+        payment = payment.round(2)
+      rescue ArgumentError
+        payment = (payment * 100.0).round / 100.0
+      end
+
+      if block_given?
+        payment = yield(payment)
+      end
+
+      periods.times do
+        interest = principal * rate
+
+        if payment > principal + interest
+          payment = principal + interest
+        end
+
+        principal = principal + interest - payment
+
+        begin
+          principal = principal.round(2)
+        rescue ArgumentError
+          principal = (principal * 100.0).round / 100.0
+        end
+
+        payments << payment
+        break if principal == 0
+        
+        p_current = p_current + 1
+      end
+    end
+
+    payments
+  end
+
+  # Return the number of periods needed to pay off a loan with the
+  # given payment.
+  def Finance.nper(payment, rate, principal)
+    -(Math.log(1-((principal/payment)*rate))) / Math.log(1+rate)
+  end
 end

data/lib/rates.rb

@@ -2,88 +2,92 @@ require 'rubygems'
 require 'flt'
 
 class Rate
-	attr_accessor :duration
-	attr_accessor :periods
-	attr_accessor :nominal
+  attr_accessor :duration
+  attr_accessor :periods
+  attr_accessor :nominal
+
+  def ==(rate)
+    self.nominal == rate.nominal and self.periods == rate.periods
+  end
 
   # Alias method for *effective*.
-	def apr=(apr)
-		self.effective = apr
-	end
+  def apr=(apr)
+    self.effective = apr
+  end
 
-	def apr
-		self.effective
-	end
+  def apr
+    self.effective
+  end
 
   # Alias method for *effective*.
-	def apy=(apy)
-		self.effective = apy
-	end
-
-	def apy
-		self.effective
-	end
-
-	def effective=(rate)
-		unless @periods == Flt::DecNum.infinity
-			@nominal = @periods * ((1 + rate) ** (1 / @periods) - 1)
-		else
-			@nominal = Math.log(rate + 1)
-		end
-	end
-
-	def effective
-		unless @periods == Flt::DecNum.infinity
-			(1 + @nominal / @periods) ** @periods - 1
-		else
-			@nominal.exp - 1
-		end
-	end
-
-	def initialize(rate, type, opts={})
-		# Make sure the rate is a decimal.
-		unless rate.class == Flt::DecNum
-			rate = Flt::DecNum rate.to_s 
-		end
-
-		# Set the compounding interval.
-		compounding = opts.fetch(:compounds, :monthly)
-
-		translate = {
-			:annually => Flt::DecNum(1),
-			:continuously => Flt::DecNum.infinity,
-			:daily => Flt::DecNum(365),
-			:monthly => Flt::DecNum(12),
-			:quarterly => Flt::DecNum(4),
-			:semiannually => Flt::DecNum(2)
-			}
-
-		if translate.has_key? compounding
-			@periods = translate.fetch compounding
-		elsif compounding.kind_of? Numeric
-			@periods = Flt::DecNum compounding.to_s 
-		end
-
-		# Set the rate in the proper way, based on the value of :type:.
-		if %w{apr apy effective}.include? type.to_s
-			self.effective = rate
-		else
-			@nominal = rate
-		end
-
-		# Set the remainder of the attributes provided in :opts:.
-		opts.each do |key, value|
-			unless key == :compounds
-			  send("#{key}=", value)
-			end
-		end
-	end
-
-	def inspect
-		"Rate.new(#{self.apr.round(6)}, :apr)"
-	end
-
-	def monthly
-		(self.effective / 12).round(6)
-	end
+  def apy=(apy)
+    self.effective = apy
+  end
+
+  def apy
+    self.effective
+  end
+
+  def effective=(rate)
+    unless @periods == Flt::DecNum.infinity
+      @nominal = @periods * ((1 + rate) ** (1 / @periods) - 1)
+    else
+      @nominal = Math.log(rate + 1)
+    end
+  end
+
+  def effective
+    unless @periods == Flt::DecNum.infinity
+      (1 + @nominal / @periods) ** @periods - 1
+    else
+      @nominal.exp - 1
+    end
+  end
+
+  def initialize(rate, type, opts={})
+    # Make sure the rate is a decimal.
+    unless rate.class == Flt::DecNum
+      rate = Flt::DecNum rate.to_s 
+    end
+
+    # Set the compounding interval.
+    compounding = opts.fetch(:compounds, :monthly)
+
+    translate = {
+      :annually => Flt::DecNum(1),
+      :continuously => Flt::DecNum.infinity,
+      :daily => Flt::DecNum(365),
+      :monthly => Flt::DecNum(12),
+      :quarterly => Flt::DecNum(4),
+      :semiannually => Flt::DecNum(2)
+      }
+
+    if translate.has_key? compounding
+      @periods = translate.fetch compounding
+    elsif compounding.kind_of? Numeric
+      @periods = Flt::DecNum compounding.to_s 
+    end
+
+    # Set the rate in the proper way, based on the value of :type:.
+    if %w{apr apy effective}.include? type.to_s
+      self.effective = rate
+    else
+      @nominal = rate
+    end
+
+    # Set the remainder of the attributes provided in :opts:.
+    opts.each do |key, value|
+      unless key == :compounds
+        send("#{key}=", value)
+      end
+    end
+  end
+
+  def inspect
+    "Rate.new(#{self.apr.round(6)}, :apr)"
+  end
+
+  def monthly
+    (self.effective / 12).round(15)
+  end
 end

data/lib/timespan.rb

@@ -1,10 +1,10 @@
 class Numeric
-	def months
-		self
-	end
+  def months
+    self
+  end
 
-	# Return the number of months.
-	def years
-		self * 12
-	end
+  # Return the number of months.
+  def years
+    self * 12
+  end
 end

data/test/test_amortization.rb

@@ -4,35 +4,168 @@ require 'flt/d'
 require 'test/unit'
 
 class TestBasicAmortization < Test::Unit::TestCase
-	def setup
-		@rate = Rate.new(0.0375, :apr, :duration => 30.years)
-		@amortization = Amortization.new(D(200000), @rate)
-	end
-
-	def test_balance
-		assert_equal D(0), @amortization.balance
-	end
-
-	def test_interest_sum
-		assert_equal D('133443.53'), @amortization.interest.sum
-	end
-
-	def test_payment
-		assert_equal D('-926.23'), @amortization.payment
-	end
-
-	def test_payments
-		payments = [ D('-926.23') ] * @rate.duration
-		# Account for rounding errors in last payment.
-		payments[-1] = D('-926.96')
-		assert_equal payments, @amortization.payments
-	end
-
-	def test_payments_sum
-		assert_equal D('-333443.53'), @amortization.payments.sum
-	end
-
-	def test_principal
-		assert_equal D(200000), @amortization.principal
-	end
+  def interest_in_period(principal, rate, payment, period)
+    -(-rate*principal*(1+rate)**(period-1) - payment*((1+rate)**(period-1)-1)).round(2)
+  end
+
+  def setup
+    @rate = Rate.new(0.0375, :apr, :duration => 30.years)
+    @principal = D(200000)
+    @amortization = Amortization.new(@principal, @rate)
+  end
+
+  def test_balance
+    assert @amortization.balance.zero?
+  end
+
+  def test_duration
+    assert_equal 360, @amortization.duration
+  end
+
+  def test_interest
+    0.upto 359 do |period|
+      assert_equal @amortization.interest[period], interest_in_period(@principal, @rate.monthly, @amortization.payment, period+1)
+    end
+  end
+
+  def test_interest_sum
+    assert_equal D('133443.53'), @amortization.interest.sum
+  end
+
+  def test_payment
+    assert_equal D('-926.23'), @amortization.payment
+  end
+
+  def test_payments
+    payments = [ D('-926.23') ] * @rate.duration
+    # Account for rounding errors in last payment.
+    payments[-1] = D('-926.96')
+    assert_equal payments, @amortization.payments
+  end
+
+  def test_payments_sum
+    assert_equal D('-333443.53'), @amortization.payments.sum
+  end
+
+  def test_principal
+    assert_equal @principal, @amortization.principal
+  end
+
+  def test_sum
+    assert_equal D(0), @amortization.payments.sum + @amortization.interest.sum + @amortization.principal
+  end
+end
+
+class TestAdjustableAmortization < Test::Unit::TestCase
+  def setup
+    @rates = []
+    0.upto 9 do |adj|
+      @rates << Rate.new(0.0375 + (D('0.01') * adj), :apr, :duration => 3.years)
+    end
+    @principal = D(200000)
+    @amortization = Amortization.new(@principal, *@rates)
+  end
+
+  def test_balance
+    assert @amortization.balance.zero?
+  end
+
+  def test_duration
+    assert_equal 360, @amortization.duration
+  end
+
+  def test_interest_sum
+    assert_equal D('277505.92'), @amortization.interest.sum
+  end
+
+  def test_payment
+    assert_nil @amortization.payment
+  end
+
+  def test_payments
+    values = %w{926.23 1033.73 1137.32 1235.39 1326.30 1408.27 1479.28 1537.03 1578.84 1601.66 1601.78}
+    values.collect!{ |v| -D(v) }
+    
+    payments = []
+    values[0,9].each do |v|
+      36.times do
+        payments << v
+      end
+    end
+
+    35.times { payments << values[9] }
+    payments << values[10]
+
+    payments.each_with_index do |payment, index|
+      assert_equal payment, @amortization.payments[index]
+    end
+  end
+
+  def test_payment_sum
+    assert_equal D('-477505.92'), @amortization.payments.sum
+  end
+
+  def test_principal
+    assert_equal @principal, @amortization.principal
+  end
+
+  def test_sum
+    assert_equal D(0), @amortization.payments.sum + @amortization.interest.sum + @amortization.principal
+  end
+end
+
+class TestExtraPaymentAmortization < Test::Unit::TestCase
+  def setup
+    @rate = Rate.new(0.0375, :apr, :duration => 30.years)
+    @principal = D(200000)
+    @amortization = Amortization.new(@principal, @rate){ |period| period.payment - 100 }
+  end
+
+  def test_additional_payments_sum
+    assert_equal D('-30084.86'), @amortization.additional_payments.sum
+  end
+  
+  def test_balance
+    assert @amortization.balance.zero?
+  end
+
+  def test_duration
+    assert_equal 301, @amortization.duration
+  end
+
+  def test_interest_sum
+    assert_equal D('108880.09'), @amortization.interest.sum
+  end
+
+  def test_payment
+    assert_equal D('-1026.23'), @amortization.payment
+  end
+
+  def test_payment_sum
+    assert_equal D('-308880.09'), @amortization.payments.sum
+  end
+
+  def test_principal
+    assert_equal @principal, @amortization.principal
+  end
+
+  def test_sum
+    assert_equal D(0), @amortization.payments.sum + @amortization.interest.sum + @amortization.principal
+  end
+end
+
+class TestNumericMethod < Test::Unit::TestCase
+  def test_simple
+    rate = Rate.new(0.0375, :apr, :duration => 30.years)
+    amt_method = 300000.amortize(rate)
+    amt_class  = Amortization.new(300000, rate)
+    assert_equal amt_method, amt_class
+  end
+
+  def test_with_block
+    rate = Rate.new(0.0375, :apr, :duration => 30.years)
+    amt_method = 300000.amortize(rate){ |period| period.payment-300 }
+    amt_class  = Amortization.new(300000, rate){ |period| period.payment-300 }
+    assert_equal amt_method, amt_class
+  end
 end

data/test/test_cashflows.rb

@@ -2,13 +2,13 @@ require 'cashflows'
 require 'test/unit'
 
 class TestIRR < Test::Unit::TestCase
-	def test_simple
-		assert_in_delta(0.143, [-4000,1200,1410,1875,1050].irr, 0.001)
-	end
+  def test_simple
+    assert_in_delta(0.143, [-4000,1200,1410,1875,1050].irr, 0.001)
+  end
 end
 
 class TestNPV < Test::Unit::TestCase
-	def test_simple
-		assert_in_delta(49.211, [-100.0, 60, 60, 60].npv(0.1), 0.001)
-	end
+  def test_simple
+    assert_in_delta(49.211, [-100.0, 60, 60, 60].npv(0.1), 0.001)
+  end
 end

data/test/test_rates.rb

@@ -4,28 +4,28 @@ require 'flt/d'
 require 'test/unit'
 
 class TestRates < Test::Unit::TestCase
-	def test_apr
-		rate = Rate.new(0.0375, :apr)
-		assert_equal D('0.03687'), rate.nominal.round(5)
-	end
+  def test_apr
+    rate = Rate.new(0.0375, :apr)
+    assert_equal D('0.03687'), rate.nominal.round(5)
+  end
 
-	def test_duration
-		rate = Rate.new(0.0375, :effective, :duration => 30.years)
-		assert_equal 360, rate.duration
-	end
-		
-	def test_effective
-		rate = Rate.new(0.03687, :nominal)
-		assert_equal D('0.0375'), rate.effective.round(4)
-	end
+  def test_duration
+    rate = Rate.new(0.0375, :effective, :duration => 30.years)
+    assert_equal 360, rate.duration
+  end
+    
+  def test_effective
+    rate = Rate.new(0.03687, :nominal)
+    assert_equal D('0.0375'), rate.effective.round(4)
+  end
 
-	def test_monthly
-		rate = Rate.new(0.0375, :effective)
-		assert_equal D('0.003125'), rate.monthly
-	end
+  def test_monthly
+    rate = Rate.new(0.0375, :effective)
+    assert_equal D('0.003125'), rate.monthly
+  end
 
-	def test_nominal
-		rate = Rate.new(0.0375, :effective)
-		assert_equal D('0.03687'), rate.nominal.round(5)
-	end
+  def test_nominal
+    rate = Rate.new(0.0375, :effective)
+    assert_equal D('0.03687'), rate.nominal.round(5)
+  end
 end

data/test/test_timespan.rb

@@ -2,11 +2,11 @@ require 'finance'
 require 'test/unit'
 
 class TestTime < Test::Unit::TestCase
-	def test_months
-		assert_equal 360, 360.months
-	end
+  def test_months
+    assert_equal 360, 360.months
+  end
 
-	def test_years
-		assert_equal 360, 30.years
-	end
+  def test_years
+    assert_equal 360, 30.years
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: finance
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Bill Kranec
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-21 00:00:00 Z
+date: 2011-06-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: flt