bondy 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4bd8591753225fb2dd5eee19be53942e7055ad9
+  data.tar.gz: 5f999a6867d35f3a5d11b31f4c259cf8503aad02
+SHA512:
+  metadata.gz: 52045214b394a7764f473c7ceaf690c8e4bd2ff4c06e088a6c9f03229df77bb428611e6b3f0388314591319a91a85ec0ca49ba7de9ce3703b1063525ef62481e
+  data.tar.gz: c9f62d6dc535cff97213c8a71fd88bb1891791d56b9b1f4866ca9104d7b17be2332629c85537d2328c2db7a8a4bca985f61ea803fe33840698509cc27a7a8b9a

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/README.*
+/_minted-*/*

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bondy.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    bondy (0.3.0)
+      fat_core
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    byebug (9.1.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.0.5)
+    damerau-levenshtein (1.3.0)
+    diff-lcs (1.3)
+    fat_core (4.2.2)
+      activesupport
+      damerau-levenshtein
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    minitest (5.11.1)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.5.1)
+      byebug (~> 9.1)
+      pry (~> 0.10)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bondy!
+  bundler (~> 1.10)
+  pry
+  pry-byebug
+  rake (~> 10.0)
+  rspec
+
+BUNDLED WITH
+   1.16.0.pre.3

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bondy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bondy.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bondy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bondy'
+  spec.version       = Bondy::VERSION
+  spec.authors       = ['Daniel E. Doherty']
+  spec.email         = ['ded-law@ddoherty.net']
+
+  spec.summary       = 'Bond financial calculations.'
+  spec.description   = 'Library for performing bond calculations'
+  spec.homepage      = 'https://github.com/ddoherty03/fat_table'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'fat_core'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+end

data/exe/bondy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "bondy"

data/lib/bondy.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+
+require 'fat_core'
+
+require 'bondy/version'
+require 'bondy/core_ext'
+require 'bondy/cash_flow_point'
+require 'bondy/annuity'
+require 'bondy/bond'
+
+require 'byebug'
+
+module Bondy
+  # Your code goes here...
+end

data/lib/bondy/annuity.rb

@@ -0,0 +1,30 @@
+module Bondy
+  class Annuity
+    attr_reader :periods, :amount
+
+    def initialize(periods: 1, amount: 0.0)
+      @periods = periods
+      @amount = amount
+    end
+
+    def to_s
+      "Annuity[#{@periods} periods of #{@amount}]"
+    end
+
+    # Return present value using rate as the
+    # per-period discount rate of this annuity
+    def present_value(rate: nil)
+      raise ArgumentError,
+            "Annuity\#present_value require rate: keyword param" unless rate
+      return periods * amount if rate == 0.0
+      if rate < 0.0
+        # If rate negative, find future value
+        k = (1.0 + rate.abs)
+      else
+        k = 1.0 / (1.0 + rate)
+      end
+      pv = k * (1.0 - k**periods) / (1.0 - k)
+      pv * amount
+    end
+  end
+end

data/lib/bondy/bond.rb

@@ -0,0 +1,684 @@
+module Bondy
+  class Bond
+    attr_reader :maturity, :coupon, :term, :issue_date, :face, :frq, :eom
+
+    def initialize(maturity: nil, issue_date: nil, term: 30,
+                   face: 1000.0, coupon: 0.0, frq: 2, eom: false)
+      @maturity = maturity ? Date.ensure(maturity) : nil
+      @issue_date = issue_date ? Date.ensure(issue_date) : nil
+      @term = term.to_i if term
+
+      # Compute @maturity, @issue_date, and @term
+      # At least one must be defined
+      # The following is a rather tedious walk through all the
+      # possibilites of which of the three are defined.
+      if issue_date.nil? && term.nil? && maturity.nil?
+        raise ArgumentError,
+              "Bond.new must supply at least maturity: parameter
+              (assumes 30-year term) or supply two
+              of maturity:, term:, and issue_date:"
+      elsif maturity && (issue_date.nil? && term.nil?)
+        # Maturity defined, compute term and issue
+        @term = 30
+        @issue_date = Date.new(@maturity.year - @term,
+                               @maturity.month, @maturity.day)
+      elsif issue_date && (maturity.nil? && term.nil?)
+        # Issue defined, compute maturity and term
+        @term = 30
+        @maturity = Date.new(@issue_date.year + @term,
+                             @issue_date.month, @issue_date.day)
+      elsif term && (maturity.nil? && issue_date.nil?)
+        # Term defined, compute maturity and issue
+        # Assume issue is today
+        @term = term.to_i
+        @issue_date = Date.today
+        @maturity = Date.new(@issue_date.year + @term,
+                             @issue_date.month, @issue_date.day)
+      elsif (maturity && term) && !issue_date
+        # Maturity and term defined, compute issue
+        @issue_date = Date.new(@maturity.year - @term,
+                               @maturity.month, @maturity.day)
+      elsif (issue_date && term) && !maturity
+        # Issue and term defined, compute maturity
+        @maturity = Date.new(@issue_date.year + @term,
+                             @issue_date.month, @issue_date.day)
+
+      elsif (issue_date && maturity) && term
+        # Issue and maturity defined, compute term
+        if @maturity.month == @issue_date.month &&
+           @maturity.day == @issue_date.day
+          # Make @term and integer if month and day are the same
+          @term = @maturity.year - @issue_date.year
+        else
+          # Else, punt
+          @term = (@maturity - @issue_date) / 365.25
+        end
+      elsif issue_date && maturity && term
+        # All three defined
+        nil
+      else
+        # None defined
+        raise(ArgumentError,
+              'Bond.new must define at least one of :maturity, :issue, or :term.')
+      end
+      # Now check @term, @maturity, and @issue_date for sanity
+      unless @maturity > @issue_date
+        raise(ArgumentError,
+              "Bond maturity #{@maturity} must be later than issue #{@issue_date}.")
+      end
+      unless @term > 0 && @term <= 100
+        raise(ArgumentError,
+              "Bond term (#{@term}) not credible.  Use life of Bond in years.")
+      end
+
+      #################################################
+      # Coupon
+      if coupon < 0.0 || coupon > 1.0
+        raise(ArgumentError,
+              'Nonsense coupon rate (#{coupon}).  Use decimals, not percentages.')
+      end
+      @coupon = coupon
+
+      # Face
+      if face <= 0
+        raise(ArgumentError, "Face of bond must be positive (#{face}).")
+      end
+      @face = face
+
+      # Frequency
+      unless [1, 2, 3, 4, 6, 12].include?(frq)
+        raise(ArgumentError,
+              "Coupon frequency (#{frq}) must be a divisor of 12.")
+      end
+      @frq = frq
+
+      # Eom
+      # eom is true only if coupons are always paid on the last day of the
+      # month.  Normally, in the US, bonds pay interest on a fixed day of
+      # the month, e.g., the 1st or the 15th, and eom is false for these.
+      # Its effect is to modify the day-count convention.
+      # See Bond#factor below.
+      @eom = eom
+    end
+
+    def to_s
+      "Bond[#{face}, Due #{maturity}, Coup #{coupon}, #{frq} per yr, Iss #{issue_date}.]"
+    end
+
+    # Return the amount of each coupon payment.
+    def coupon_amount
+      face * coupon / frq
+    end
+
+    # Return the dates of each coupon payment on or after the date
+    # ~on_or_after~.
+    def coupon_dates(on_or_after: issue_date)
+      return [] if on_or_after >= maturity
+      dates = []
+      cur_date = on_or_after
+      while cur_date < maturity
+        cur_date = next_coupon_date(cur_date)
+        dates << cur_date
+      end
+      dates
+    end
+
+    def cash_flows(on_or_after: issue_date)
+      flows = []
+      coupon_dates(on_or_after).each do |dt|
+        flows << CashFlowPoint.new(date: dt, amount: coupon_amount)
+      end
+      flows << CashFlowPoint.new(date: maturity, amount: face)
+      flows
+    end
+
+    def price(yld: 0.0, settle_date: issue_date, convention: 0,
+              clean: true, verbose: false)
+      settle_date = Date.ensure(settle_date)
+      if settle_date > maturity
+        raise ArgumentError,
+              "Settlement date #{settle_date} later than maturity date #{maturity}."
+      end
+
+      # Convention for how interest is calculated between interest
+      # payment dates.  See factor() and coupon_factor() below.
+      # 0 -- US (NASD) 30/360 (default)
+      # 1 -- Actual/actual
+      # 2 -- Actual/360
+      # 3 -- Actual/365
+      # 4 -- European 30/360
+      # See the details in the Bond#factor function below
+      unless [0, 1, 2, 3, 4].include?(convention)
+        raise(ArgumentError, 'Day count convention must be 0, 1, 2, 3, or 4.')
+      end
+
+      # PV of coupons paid after first coupon date
+      # Yield per period, discount rate
+      next_coup_date = next_coupon_date(settle_date)
+      prior_coup_date = prior_coupon_date(settle_date)
+      r = yld / frq
+
+      accrued_fraction = factor(date: settle_date, convention: convention)
+      accrued_coupon = coupon_amount * accrued_fraction
+
+      if verbose
+        puts "\n#####################################################"
+        puts 'Bond Price:'
+        puts 'Calculating clean price.' if clean
+        puts 'Calculating dirty price.' if !clean
+        puts "Face Value: #{face}"
+        puts "Coupon Rate: #{coupon}"
+        puts "Per period coupon payment: \$#{coupon_amount}"
+        puts "Yield: #{yld}"
+        puts "Per period yield: #{r}"
+        puts "Frequency: #{frq}"
+        puts "Convention: #{convention}"
+        puts "Prior Coupon: #{prior_coup_date}"
+        puts "Settlement: #{settle_date.iso}"
+        puts "Accrual fraction: #{accrued_fraction}"
+        puts "Next Coupon: #{next_coup_date.iso}"
+        puts "Maturity date: #{maturity.iso}"
+        puts "Periods from prior coupon to maturity: #{periods_remaining(settle_date)}"
+      end
+
+      if periods_remaining(settle_date) <= 1
+        yield_to_maturity = r * (1.0 - accrued_fraction)
+        dirty_price = (face + coupon_amount) / (1.0 + yield_to_maturity)
+        price = dirty_price - accrued_coupon
+        if verbose
+          puts 'Using single-period calculation'
+          puts "Buyer gets at maturity: #{face + coupon_amount}"
+          puts "Seller portion of coupon paid at settlement: #{accrued_coupon}"
+          puts "Yield to Maturity: #{yield_to_maturity}"
+          puts "Dirty price: #{dirty_price}"
+        end
+      else
+        # We calculate the PV of the coupon stream and the face value due at
+        # maturity as of the date of the prior coupon.
+        pv_coup = Annuity.new(periods: periods_remaining(settle_date),
+                              amount: coupon_amount)
+                    .present_value(rate: r)
+        pv_face =
+          CashFlowPoint.new(amount: face, date: maturity)
+            .value(as_of: prior_coup_date, rate: yld, frq: frq)
+
+        pv_at_prior = pv_coup + pv_face
+        # In order to get the value at the settlement date, the value at the prior
+        # coupon date needs to be increased by the required yield for the
+        # fractional period to the settlement date.
+        if settle_date > prior_coup_date
+          dirty_price =
+            CashFlowPoint.new(amount: pv_at_prior,
+                              date: prior_coup_date)
+              .value(as_of: settle_date, rate: yld, frq: frq)
+        else
+          dirty_price = pv_at_prior
+        end
+        price = dirty_price - accrued_coupon
+        if verbose
+          puts "Present value of coupon stream at prior coupon date: #{pv_coup}\n"
+          puts "Present value of face amount at prior coupon date: #{pv_face}"
+          puts "Present value of bond amount at prior coupon date: #{pv_at_prior}"
+          puts "Present value of bond amount at settlement date: #{dirty_price}"
+          puts "Accrued coupon at settlement: #{accrued_coupon}"
+          puts "The dirty bond price is #{dirty_price}"
+          puts "The clean bond price is #{price}\n"
+        end
+      end
+      price = dirty_price unless clean
+      puts "Bond price: #{price}" if verbose
+      price
+    end
+
+    def yld(price: face, settle_date: maturity, convention: 0, verbose: false)
+      raise ArgumentError, "Negative price (#{price})." if price < 0
+      settle_date = Date.ensure(settle_date)
+
+      unless [0, 1, 2, 3, 4].include?(convention)
+        raise ArgumentError, 'Rounding convention must be 0, 1, 2, 3, or 4.'
+      end
+
+      if verbose
+        puts ""
+        puts "#####################################################"
+        puts "Yield:"
+        puts "Settlement: #{settle_date}"
+        puts "Maturity date: #{maturity}"
+        puts "Face Value: #{face}"
+        puts "Coupon Rate: #{coupon}"
+        puts "Frequency: #{frq}"
+        puts "Convention: #{convention}"
+        puts "Price: #{price}"
+      end
+
+
+      if periods_remaining(settle_date) <= 1
+        # Use direct calculation if one or no periods left.
+        prior_coup_date = prior_coupon_date(settle_date)
+        days_from_prior_to_settle = settle_date - prior_coup_date
+        days_from_prior_to_maturity = maturity - prior_coup_date
+        days_from_settle_to_maturity = maturity - settle_date
+        accrued_fraction = factor(date: settle_date, convention: convention)
+        unaccrued_fraction = 1.0 - accrued_fraction
+        sellers_coupon = coupon_amount * accrued_fraction
+        buyers_coupon = coupon_amount * unaccrued_fraction
+
+        if unaccrued_fraction != 0.0
+          annualization_factor = frq / unaccrued_fraction
+          yld = (face + coupon_amount) / (price + sellers_coupon) - 1.0
+        elsif days_from_settle_to_maturity > 0
+          # Here, the buyer is paying for the face amount with no coupon
+          # because he is buying close enough to maturity that, based on the
+          # interest rate convention, all of the coupon goes to the seller.
+          # Still there is at least one day remaining before maturity, so a
+          # yield can be computed based on an assumed number of days in the
+          # year.
+          if [0, 2, 4].include?(convention)
+            days_in_year = 360
+          elsif convention == 3
+            days_in_year = 365
+          else
+            # Actual days, depending on leap year
+            days_in_year = settle_date.is_leap_year ? 366 : 365;
+          end
+          yld = face / price - 1.0
+          annualization_factor = days_in_year / days_from_settle_to_maturity
+        else
+          # Settlement on the maturity date.  This should not be reached
+          # because settlement on maturity returns undef and logs an error
+          # above.  But just as a place-holder in case this comes up later,
+          # this is how I would handle it.  Here, the buyer is paying for
+          # the $face amount with no coupon because he is buying close
+          # enough to maturity that, based on the interest rate convention,
+          # all of the coupon goes to the seller. So, if the buyer is paying
+          # more than face, he's getting a infinite negative yield, if he's
+          # paying less than face, he's getting an infinite positive yield,
+          # and if he's paying face, he's getting a zero yield.
+          if price > face
+            # Negative infinite yield
+            yld = -1.00
+          elsif price < face
+            yld = 1.00
+          else
+            yld = 0.0
+          end
+          # Arbitrary big factor for infinite yields
+          annualization_factor = 1000.0
+        end
+
+        if verbose
+          puts "Using direct calculation for #{periods_remaining(settle_date)} periods"
+          puts "Days from prior coupon to settlement: #{days_from_prior_to_settle}"
+          puts "Days from settlement to maturity: #{days_from_settle_to_maturity}"
+          puts "Days from prior coupon to maturity: #{days_from_prior_to_maturity}"
+          puts "Accrued fraction: #{accrued_fraction}"
+          puts "Unaccrued fraction: #{unaccrued_fraction}"
+          puts "Full coupon: #{coupon_amount}"
+          puts "Seller's portion of coupon: #{sellers_coupon}"
+          puts "Buyer's portion of coupon: #{buyers_coupon}"
+          puts "Raw yield: #{yld}"
+          puts "Annualization factor: #{annualization_factor}"
+        end
+        yld *= annualization_factor
+      else
+        # Use binary search to find yield that produces a bond price
+        # equal to $price, within the desired toleration, expressed
+        # as the number of decimal places accuracy.
+        low = -9_999.0
+        high = 10_000.00
+
+        # Loop until the computed price is within places decimal places of the
+        # given price or until we hit max_iter iterations.
+        places = 7
+        max_iter = 100
+        iterations = 0
+        until low.nearly?(high, places) || iterations >= max_iter
+          iterations += 1
+          mid = (low + high) / 2.0
+          computed_price = self.price(yld: mid, settle_date: settle_date,
+                                      convention: convention, verbose: verbose)
+          if verbose
+            printf("Iter [%02d]: yld [%0.*f, <%0.*f>, %0.*f]; price [%0*.*f]; target [%0*.*f].\n",
+                   iterations, places, low, places, mid, places, high, places + 4,
+                   places, computed_price, places + 4, places, price)
+          end
+          if computed_price > price
+            low = mid
+          else
+            high = mid
+          end
+        end
+        mid
+      end
+    end
+
+    def macaulay_duration(yld: 100.0, settle_date: maturity, convention: 0,
+                          verbose: false)
+      # Return the "Macaulay duration" of a bond, which is
+      # calculated as the weighted average of each cash
+      # payment, each weighted by the number of years to maturity
+      # and discounted back to the (settlement) date, which is
+      # the date as of which the duration is being measured.
+
+      settle_date = Date.ensure(settle_date)
+
+      unless [0, 1, 2, 3, 4].include?(convention)
+        raise ArgumentError, 'Day count convention must be 0, 1, 2, 3, or 4.'
+      end
+
+      # For a zero-coupon bond, the duration is simply the number
+      # of years to maturity since the sole payment occurs at
+      # maturity.  Deal with this simple case specially.
+      return months_diff(maturity, settle_date) / 12 if coupon == 0.0
+
+      if verbose
+        puts "\nMacaulay Duration:"
+        puts "Settlement: #{settle_date}"
+        puts "Maturity date: #{maturity}"
+        puts "Face Value: #{face}"
+        puts "Coupon Rate: #{coupon}"
+        puts "Yield: #{yld}"
+        puts "Frequency: #{frq}"
+      end
+
+      # Yield per period, discount rate
+      r = yld / frq
+
+      # Compute moments of coupons
+      moment = 0
+      cdate = next_coupon_date(settle_date)
+      while cdate && cdate <= maturity
+        ytc = cdate.month_diff(settle_date) / 12.0
+        cf_coup = CashFlowPoint.new(amount: coupon_amount, date: cdate)
+        pv_coup = cf_coup.value(as_of: settle_date, rate: yld, frq: frq)
+        moment += ytc * pv_coup
+        if verbose
+          puts "Coup: #{cdate}; Amt: #{coupon_amount}: PV: #{pv_coup}; Yrs: #{ytc}"
+        end
+        cdate = next_coupon_date(cdate)
+      end
+
+      # Add moment of face
+      ytm = maturity.month_diff(settle_date) / 12.0
+      pvm = CashFlowPoint.new(amount: face, date: maturity)
+              .value(as_of: settle_date, rate: yld, frq: frq)
+      moment += ytm * pvm
+      if verbose
+        puts "Maturity on #{maturity}: Amount; face: PV: #{pvm}; Yrs: #{ytm}"
+        puts "Computed moment is #{moment}"
+      end
+
+      # Duration is ratio of moments to price
+      mprice = price(yld: yld, settle_date: settle_date, convention: convention)
+      puts "Computed price is #{mprice}" if verbose
+
+      # Debug
+      if verbose
+        puts "Per period yld: #{r}"
+        puts "Per period coupon payment: \$#{coupon_amount}"
+        puts "The Macaulay duration is #{moment / mprice}\n"
+      end
+
+      moment / mprice
+    end
+
+    # Return the "Modified duration" of a bond, which is calculated as the
+    # Macaulay duration divided by (1 + $yld/$frq).
+    def modified_duration(yld: 100.0, settle_date: Date.today, convention: 0,
+                          verbose: false)
+      settle_date = Date.ensure(settle_date)
+
+      unless [0, 1, 2, 3, 4].include?(convention)
+        raise ArgumentError, 'Day count convention must be 0, 1, 2, 3, or 4.'
+      end
+
+      if verbose
+        puts "\n#####################################################"
+        puts 'Modified Duration:'
+        puts "Settlement: #{settle_date}"
+        puts "Maturity date: #{maturity}"
+        puts "Face Value: #{face}"
+        puts "Coupon Rate: #{coupon}"
+        puts "Yield: #{yld}"
+        puts "Frequency: #{frq}"
+      end
+
+      macd = macaulay_duration(yld: yld, settle_date: settle_date,
+                               convention: convention, verbose: verbose)
+      macd / (1 + yld / frq)
+    end
+
+    private
+
+    # Returns fraction of *annual* coupon that has been
+    # accrued by date2 for this bond, following the day-count
+    # convention, convention.
+    def factor(date: nil, convention: 0)
+      raise ArgumentError, 'factor requires date: argument' unless date
+      date2 = Date.ensure(date)
+
+      # Return the fraction of the year that has elapsed on
+      # date2, typically the settlement date.  date1 is the
+      # date on which the period begins, usually the prior
+      # coupon date date2 is the date of payment or settlement
+      # date date3 is the date on which the period ends,
+      # usually the next coupon date Source: Wikipedia "Day
+      # count conventions"
+      #
+      # Note: date3 is not used in any of the conventions programmed for
+      # here, but it may be used in other conventions.  See the link
+      # above for where it might apply.
+
+      date1 = prior_coupon_date(date2)
+      # date3 = next_coupon_date(date2)
+
+      # Convention for how interest is calculated between
+      # interest payment dates.  This has to do with the
+      # fraction by which the annual coupon is multiplied to
+      # pay for a partial period.  The numerator is the number
+      # of days that have elapsed; The demoniator is the
+      # number of days in the entire year.  These
+      # involve assumptions about the number of days in the
+      # months that fall within the partial period.  They will
+      # assume either that every month consists of 30 days,
+      # even if the particular period in which the payment
+      # occurs contains February, July, and August, or they
+      # will take into account the actual number of days in
+      # the particular period.
+
+      # comv =
+      # 0 -- US (NASD) 30/360 (default)
+      # 1 -- Actual/actual
+      # 2 -- Actual/360
+      # 3 -- Actual/365
+      # 4 -- European 30/360
+
+      # The following are extracted from the dates for the
+      # 30/360 methods (0 and 4)
+      d1 = date1.day
+      d2 = date2.day
+      # d3 = date3.day
+      m1 = date1.month
+      m2 = date2.month
+      # m3 = date3.month
+      y1 = date1.year
+      y2 = date2.year
+      # y3 = date3.year
+
+      case convention
+      when 0
+        #############################################################
+        # From  www.eclipsesoftware.biz/DayCountConventions.html#x3_01a
+        #############################################################
+        # 3.01a - 30U/360
+        # The adjustment to Date1 and Date2:
+        #     * If security is EOM and (d1 = last-day-of-February) and (d2 = last-day-of-February), then change d2 to 30.
+        #     * If security is EOM and (d1 = last-day-of-February), then change d1 to 30.
+        #     * If d2 = 31 and d1 is 30 or 31, then change d2 to 30.
+        #     * If d1 = 31, then change d1 to 30.
+        # This is the convention in the U.S. for corporate, municipal, and some US Agency bonds.
+        # This convention is referred to as:
+        # Term  Sources
+        # 30/360  [SIFMA_SSCM]
+        # 30U/360 [SWX_AI]
+        # US  [SWX_AI]
+        if eom && date1.last_of_feb? && date2.last_of_feb?
+          d2 = 30
+        end
+        if eom && date1.last_of_feb?
+          d1 = 30
+        end
+        if d2 == 31 && (d1 == 30 || d1 == 31)
+          d2 = 30
+        end
+        if d1 == 31
+          d1 = 30
+        end
+        num = 360.0 * (y2 - y1) + 30.0 * (m2 - m1) + (d2 - d1)
+        den = 360.0
+        fact = (num / den)
+      when 1
+        # Actual Conventions
+
+        # This category of conventions uses the actual number
+        # of calendar days in the accrual period. The
+        # differences come in the value of Den.
+
+        # N is simply the number of days between Date1 and
+        # Date2. For example, the number of days between
+        # 2-Nov-2007 and 15-Nov-2007 is 13. Just
+        # subtract. This is notated as JulianDays(Date1,
+        # Date2).
+
+        # Actual/Actual This convention splits the accrual
+        # period into that portion in a leap year and that in
+        # a non-leap year. You include the first date in the
+        # period and exclude the ending one.
+        #
+        # The calculation is:
+        #     * Fact = ( {Nnl in non-leap year / 365} + {Nly in leap year / 366} )
+        # Example
+        # Date  Value
+        # Date1 15-Dec-2007
+        # Date2 10-Jan-2008
+        #
+        # This results in the values:
+        # Term  Calculation Value
+        # Nnl JulianDays(15-Dec-2007, 1-Jan-2008) 17
+        # Nly JulianDays(1-Jan-2008, 10-Jan-2008) 9
+        # Fact  ( {17 / 365} + {9 / 366} )  0.07116551
+        if date1.is_leap? == date2.is_leap?
+          # Both date1 and date2 are in same kind of year
+          num = (date2 - date1).to_f
+          den = 365.0
+          den = 366.0 if date1.is_leap?
+          fact = (num / den)
+        else
+          # One is in a leap, the other not
+          num1 = (Date.new(date2.year, 1, 1) - date1).to_f
+          den1 = 365.0
+          den1 = 366.0 if date1.is_leap?
+          num2 = (date2 - Date.new(date2.year, 1, 1)).to_f
+          den2 = 365.0
+          den2 = 366.0 if date2.is_leap?
+          fact = (num1 / den1) + (num2 / den2)
+        end
+      when 2
+        # A.04 - Act/360
+        # Den:
+        #     * 360
+
+        # This results in the calculation:
+        # AI = CR * (N / 360).
+        # This convention is referred to as:
+        #
+        # Term  Sources
+        # Actual/360  [ISDA_4.16_2006], [ISDA_4.16_2000], [SIFMA_SSCM],
+        #             [SIA_SSCM], [SWX_AI], [EBF_MA]
+        # Act/360 [ISDA_4.16_2006], [ISDA_4.16_2000]
+        # A/360 [ISDA_4.16_2006]
+        # French  [SWX_AI]
+        num = (date2 - date1).to_f
+        den = 360.0
+        fact = num / den
+      when 3
+        # A.03 - Act/365 (Fixed)
+        # Den:
+        #     * 365
+        # This results in the calculation:
+        # AI = CR * (N / 365).
+        num = (date2 - date1).to_f
+        den = 365.0
+        fact = num / den
+      when 4
+        # 3.03 - 30E/360 ISDA
+        # The adjustment to Date1 and Date2:
+        #     * If d1 = last day of the month, then change d1 to 30.
+        #     * If d2 = last day of the month, then change d2 to 30.
+        # However, do not make this adjustment if Date2 = MatDt and d2 = February.
+
+        # The d2 qualification for February is often omitted
+        # when this convention is discussed. We believe this
+        # is an oversight, not a variant.
+
+        # This convention is referred to as:
+        # Term  Sources
+        # 30E/360 (ISDA)  [ISDA_4.16_2006]
+        # 30E/360 [ISDA_4.16_2000]
+        # Eurobond Basis  [ISDA_4.16_2000]
+        # German  [SWX_AI]
+        # German Master [EBF_MA]
+        # 360/360 [EBF_MA]
+        unless date2 == maturity && date2.month == 2
+          if date1.last_of_month?
+            d1 = 30.0
+          end
+          if date2.last_of_month?
+            d2 = 30.0
+          end
+        end
+        num = 360.0 * (y2 - y1) + 30.0 * (m2 - m1) + (d2 - d1)
+        den = 360.0
+        fact = num / den
+      else
+        raise ArgumentError "invalid convention: #{convention}"
+      end
+      fact * frq
+    end
+
+    # Return the next coupon date *after* the given date
+    def next_coupon_date(date)
+      raise ArgumentError, "No next coupon date past #{date}" if date > maturity
+      return nil if date == maturity
+
+      next_coup_date = date + 1
+      # Step forward by days until we hit date with the same month-day as
+      # maturity
+      next_coup_date += 1 while next_coup_date.day != maturity.day
+      # Step forward by months until we hit a coupon month
+      until maturity.month_diff(next_coup_date).floor % months_per_period == 0
+        next_coup_date = next_coup_date >> 1
+      end
+      next_coup_date
+    end
+
+    # Return the prior coupon date *on or before* the given date
+    def prior_coupon_date(date)
+      if date <= issue_date
+        raise ArgumentError, "No prior coupon date before #{date}"
+      end
+      next_coupon_date(date) << months_per_period
+    end
+
+    def months_per_period
+      12 / frq
+    end
+
+    # Number of periods remaining until maturity, including the period
+    # containing the given date.
+    def periods_remaining(date)
+      return 0 if date == maturity
+      maturity.month_diff(prior_coupon_date(date)) / months_per_period
+    end
+  end
+end

data/lib/bondy/cash_flow_point.rb

@@ -0,0 +1,62 @@
+module Bondy
+  class CashFlowPoint
+    attr_reader :date, :amount
+
+    def initialize(amount: 0.0, date: Date.today)
+      @amount = amount
+      @date = Date.ensure(date)
+    end
+
+    def to_s
+      "CFP[#{@amount} @ #{@date}]"
+    end
+
+    # Return the value of this cash flow on a particular as_of date at an annual
+    # rate, rate, with frq compunding periods per year frq = 0 means simple
+    # interest---no compounding.
+    def value(as_of: Date.today, rate: 0.0, frq: 1)
+      as_of = Date.ensure(as_of)
+
+      # Check frq for sanity
+      unless [0, 1, 2, 3, 4, 6, 12].include?(frq)
+        raise(ArgumentError,
+              "Compounding frequency (#{frq}) not a divisor of 12.  Suspect.")
+      end
+
+      # Rate per period
+      r =
+        if frq == 0
+          rate
+        else
+          rate / frq
+        end
+
+      # Number of periods
+      n =
+        if frq == 0
+          as_of.month_diff(date) / 12.0
+        else
+          as_of.month_diff(date) / (12.0 / frq)
+        end
+
+      # Now the calculation
+      if frq == 0
+        # Simple interest
+        if n >= 0
+          # Payout date before value date---future value
+          amount * (1.0 + r * n)
+        else
+          # Payout date after value date---present value
+          amount / (1.0 + r * -n)
+        end
+      else
+        # Compund interest
+        if r < 0.0
+          amount / ((1.0 + r.abs)**n)
+        else
+          amount * (1.0 + r)**n
+        end
+      end
+    end
+  end
+end

data/lib/bondy/core_ext.rb

@@ -0,0 +1,2 @@
+require 'bondy/core_ext/numeric'
+require 'bondy/core_ext/date'

data/lib/bondy/core_ext/date.rb

@@ -0,0 +1,74 @@
+require 'date'
+
+class Date
+  def self.ensure(arg)
+    case arg
+    when String
+      parse(arg)
+    when Date
+      arg
+    else
+      raise ArgumentError, "can't convert #{arg} to a Date"
+    end
+  end
+
+  def self.excel(i)
+    k = i < 60 ? 1 : 0
+    Date.new(1899, 12, 30) + i + k
+  end
+
+  def month_diff(other, whole: false)
+    other = Date.ensure(other)
+    # Put dates in d0, d1 order
+    if self < other
+      k = -1
+      d0 = self
+      d1 = other
+    else
+      k = 1
+      d0 = other
+      d1 = self
+    end
+    # If both dates are last of month, return only
+    # whole months
+    whole = true if d0.last_of_month? && d1.last_of_month?
+
+    # Count number of years
+    m = (d1.year - d0.year) * 12
+    m += (d1.month - d0.month)
+    m += (d1.day - d0.day) / 30.0 unless whole
+    k * m
+  end
+
+  def is_leap?
+    y = year
+    (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
+  end
+
+  def last_of_feb?
+    return false unless month == 2
+    if is_leap?
+      day == 29 ? true : false
+    else
+      day == 28 ? true : false
+    end
+  end
+
+  def last_of_month?
+    if [1, 3, 5, 7, 8, 10, 12].include?(month) && day == 31
+      true
+    elsif [4, 6, 9, 11].include?(month) && day == 30
+      true
+    elsif last_of_feb?
+      true
+    else
+      false
+    end
+  end
+
+  private
+
+  def whole_month_diff(d)
+    month_diff(d, whole: true)
+  end
+end

data/lib/bondy/core_ext/numeric.rb

@@ -0,0 +1,15 @@
+class Numeric
+  def excel_date
+    k = to_i <= 60 ? 1 : 0
+    Date.new(1899, 12, 30) + to_i + k
+  end
+end
+
+class Float
+  # Compare floating point number for equality in $POINTS places
+  def nearly?(other, places = 7)
+    tX = sprintf("%0.#{places}f", self)
+    tY = sprintf("%0.#{places}f", other)
+    tX == tY
+  end
+end

data/lib/bondy/version.rb

@@ -0,0 +1,3 @@
+module Bondy
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: bondy
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Daniel E. Doherty
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fat_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library for performing bond calculations
+email:
+- ded-law@ddoherty.net
+executables:
+- bondy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.org
+- Rakefile
+- bin/console
+- bin/setup
+- bondy.gemspec
+- exe/bondy
+- lib/bondy.rb
+- lib/bondy/annuity.rb
+- lib/bondy/bond.rb
+- lib/bondy/cash_flow_point.rb
+- lib/bondy/core_ext.rb
+- lib/bondy/core_ext/date.rb
+- lib/bondy/core_ext/numeric.rb
+- lib/bondy/version.rb
+homepage: https://github.com/ddoherty03/fat_table
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Bond financial calculations.
+test_files: []