istox 0.1.83 → 0.1.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b813654e16bda14094395623351d865c5abf9269245401cb08aab54bc439f06b
-  data.tar.gz: 9e15ed189e7156eeecbf812f22db93bd9b2840dcf4912b67f013c6f764d07d3d
+  metadata.gz: 854004247090c0884aa24fa0c77208e6cad407509e24762291d1c1080e9d387c
+  data.tar.gz: e4a725fb85ecc5f84361da376613e2202a1e43bbcec39bbd831c3d1808f8fd5a
 SHA512:
-  metadata.gz: ad6369e5493e10b71c517271a851958894ec01eb73ff4cf736ec0085af8093235cd49ed1ddf5788743da05246f7e0a46a919a57f7008c43ece66f2e4b785372f
-  data.tar.gz: 9a7c003a0ceb7846c25b404618f39727efac4a11f8aa9872f95eac08064b70171dabf44f471111164ae12959a5ef4499df97aea5166cfd0eff9181252de17141
+  metadata.gz: b207971e2dc4c7b7239f216c3a9275ba70bed62288b8f010f78058c508fa7041c0c521ae0d276ce2f93a8d29affea1f9ef206032792cee3b26a060b4e03f1f3a
+  data.tar.gz: c2f77e3c9af27b0a7327128496960a518b714d9f71876156e1a886ec7b0c1c87c56c45357bf46c50d79943cb5559ddc28eddf3051a99e0af76f16db016208068

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    istox (0.1.82)
+    istox (0.1.83)
       binding_of_caller
       bunny (>= 2.12.0)
       graphlient

data/lib/istox/helpers/f_math.rb

@@ -44,20 +44,22 @@ module Istox
         x = 0 if x.blank?
         y = 0 if y.blank?
 
-        x = to_fixed(x)
-        y = to_fixed(y)
+        # x = to_fixed(x)
+        # y = to_fixed(y)
 
-        return ::BigDecimal.new('1').to_s if x == y
+        (::BigDecimal.new(x.to_s) / ::BigDecimal.new(y.to_s)).truncate(18).to_s
 
-        fixed1 = ::BigDecimal.new('1e18')
+        # return ::BigDecimal.new('1').to_s if x == y
 
-        return from_fixed(x.div(y, 100).mult(fixed1, 100)).to_s if x.div(y, 100).modulo(BigDecimal.new(10)).zero? && x.modulo(y).zero?
+        # fixed1 = ::BigDecimal.new('1e18')
 
-        r_y = fixed1.mult(fixed1, 100).truncate(0).div(y, 100).truncate(0)
+        # return from_fixed(x.div(y, 100).mult(fixed1, 100)).to_s if x.div(y, 100).modulo(BigDecimal.new(10)).zero? && x.modulo(y).zero?
 
-        result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed1, 100).truncate(0))
+        # r_y = fixed1.mult(fixed1, 100).truncate(0).div(y, 100).truncate(0)
 
-        result.truncate(18).to_s
+        # result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed1, 100).truncate(0))
+
+        # result.truncate(18).to_s
       end
 
       def round_up(x, digits)

data/lib/istox/quant/bond.rb

@@ -1,93 +1,232 @@
-# frozen_string_literal: true
 require 'date'
 
-# This class is modified for ISTOX use case based on open source Bondie 
-
-# YTM based on price and date:
-
-# bond = Istox::Quant::Bond.new(coupon: 0.0622, maturity_date: Date.parse('2016-08-22'), coupon_frequency: 4)
-# bond.ytm(Date.parse('2015-09-07'), price: 100.8)
-# It will not count exact yield, but it will approximate it - you can set maximum approximation error by adding approximation_error parameter to the method.
-
-# You can also check interest payments dates:
-
-# bond = Istox::Quant::Bond.new(coupon: 0.0622, maturity_date: Date.parse('2016-08-22'), coupon_frequency: 4)
-# bond.interest_payments(Date.parse('2015-09-07'))
-# Currently it will not skip weekends or other days without bond quotations, so it can be inaccurate.
-
-# Also it's possible to check price on which it will generate given yield:
-
-# bond = Istox::Quant::Bond.new(coupon: 0.0622, maturity_date: Date.parse('2016-08-22'), coupon_frequency: 4)
-# bond.price(0.05156, Date.parse('2015-09-07'))
+# https://en.wikipedia.org/wiki/Day_count_convention#30/360_Bond_Basis
+# For 360 basis: 30/360 Bond Basis
+# For 365 basis: Actual/Actual ICMA
 
+# This class is modified for ISTOX use case based on open source Bondie 
 
 module Istox
   module Quant
     class Bond
 
-      DEFAULT_APPROXIMATION_ERROR = 0.0001
+      DEFAULT_APPROXIMATION_ERROR = 0.00001
+
+      def initialize(coupon: nil, maturity_date: nil, years: nil, coupon_frequency: nil, coupon_payment_dates: nil, face_value: 100, days_of_year: 365)
+        raise "Invalid coupon #{coupon}" if (coupon.nil? || !is_number?(coupon))
+        raise "Invalid maturity_date #{maturity_date}" if (maturity_date.nil? || maturity_date.methods.include?("strftime"))
+        raise "Invalid years #{years}" if (years.nil? || !years.is_a?(Integer))
+        raise "Invalid coupon_frequency #{days_of_year}" if (coupon_frequency.nil? || !is_number?(coupon))
+        raise "Invalid coupon_payment_dates #{coupon_payment_dates}" if (coupon_payment_dates.nil? || coupon_payment_dates.count == 0 || coupon_payment_dates.any? { |date| date > maturity_date })
+        raise "Invalid days_of_year #{days_of_year}" if (days_of_year != 365 && days_of_year != 360)
 
-      def initialize(coupon: nil, maturity_date: nil, coupon_frequency: nil, face_value: 100, days_of_year: 365)
         @coupon               = coupon
         @maturity_date        = maturity_date
+        @years                = years
         @coupon_frequency     = coupon_frequency
         @days_of_year         = days_of_year
         @face_value           = face_value
+        @coupon_payment_dates = coupon_payment_dates.sort
+        @start_date           = (@maturity_date-@years.years)
       end
 
-      def price(ytm, date, fees: 0)
-        price_for_irr(irr_from_ytm(ytm), date, fees: fees)
+      def price(ytm, date, ex_coupon_date: nil, fees: 0)
+        # price_for_irr(irr_from_ytm(ytm), date, fees: fees)
+        price = price_for_irr(ytm/@coupon_frequency, date, ex_coupon_date: ex_coupon_date, fees: fees)
+        price.round(2)
       end
 
-      def interest_payments(from_date)
+      # def interest_payments(from_date)
+      #   payments = []
+      #   date = @maturity_date
+      #   while date >= from_date
+      #     payments << date
+      #     date = date.prev_month(12/@coupon_frequency)
+      #   end
+      #   payments.sort
+      # end
+
+      def coupon_payments(from_date)
         payments = []
-        date = @maturity_date
-        while date >= from_date
-          payments << date
-          date = date.prev_month(12/@coupon_frequency)
+
+        @coupon_payment_dates.each do |payment_date|
+          if payment_date > from_date
+            payments << payment_date
+          end
         end
+
         payments.sort
       end
 
-      def ytm(date, price: 100, fees: 0, approximation_error: DEFAULT_APPROXIMATION_ERROR)
-        ytm_down, ytm_up = ytm_limits(price, date, fees: fees)
-        approximate_ytm(ytm_down, ytm_up, price, date, fees: fees, approximation_error: approximation_error)
+      def ytm(date, ex_coupon_date: nil, price: 100, fees: 0, approximation_error: DEFAULT_APPROXIMATION_ERROR)
+        ytm_down, ytm_up = ytm_limits(price, date, ex_coupon_date: ex_coupon_date, fees: fees)
+        approximate_ytm(ytm_down, ytm_up, price, date, ex_coupon_date: ex_coupon_date, fees: fees, approximation_error: approximation_error)
       end
 
 
       private
 
-      def irr_from_ytm(ytm)
-        (ytm/@coupon_frequency.to_f + 1) ** @coupon_frequency - 1
+      def is_365?
+        @days_of_year == 365
+      end
+
+      def add_month(mydate, n)
+        if mydate.month != mydate.next_day.month 
+          # month end
+          (mydate.next_day + n.month).prev_day
+        else
+          mydate.next_day + n.month
+        end
       end
 
+      def is_month_end?(mydate)
+        mydate.month != mydate.next_day.month 
+      end
+
+      def is_number?(val)
+        val.is_a?(Integer) || val.is_a?(Float) || val.is_a?(BigDecimal)
+      end
+          
+      def irr_from_ytm(ytm)
+        (ytm/@coupon_frequency.to_d + 1) ** @coupon_frequency - 1
+      end
 
-      def approximate_ytm(ytm_down, ytm_up, price, date, fees: 0, approximation_error: DEFAULT_APPROXIMATION_ERROR)
+      def approximate_ytm(ytm_down, ytm_up, price, date, ex_coupon_date: nil, fees: 0, approximation_error: DEFAULT_APPROXIMATION_ERROR)
         approx_ytm = (ytm_up + ytm_down) / 2.0
         return approx_ytm if ((ytm_up - approx_ytm)/approx_ytm).abs <= approximation_error
-        p = price(approx_ytm, date, fees: fees)
+        p = price(approx_ytm, date, ex_coupon_date: ex_coupon_date, fees: fees)
         ytm_down, ytm_up = p < price ? [ytm_down, approx_ytm] : [approx_ytm, ytm_up]
-        approximate_ytm(ytm_down, ytm_up, price, date, fees: fees, approximation_error: approximation_error)
+        approximate_ytm(ytm_down, ytm_up, price, date, ex_coupon_date: ex_coupon_date, fees: fees, approximation_error: approximation_error)
       end
 
-      def ytm_limits(price, date, fees: 0)
+      def ytm_limits(price, date, ex_coupon_date: nil, fees: 0)
         ytm_up = 0.1
-        ytm_up *= 10 while price(ytm_up, date, fees: fees) > price
+        ytm_up *= 10 while price(ytm_up, date, ex_coupon_date: ex_coupon_date,fees: fees) > price
         # IRR will be never lower than -1, so YTM should be never lower than -coupon_frequency (see irr_from_ytm)
-        ytm_down = price(0, date, fees: fees) > price ? 0.0 : -@coupon_frequency.to_f
+        ytm_down = price(0, date, ex_coupon_date: ex_coupon_date, fees: fees) > price ? 0.0 : -@coupon_frequency.to_d
         [ytm_down, ytm_up]
       end
 
-      def price_for_irr(irr, date, fees: 0)
+      # def price_for_irr(irr, date, fees: 0)
+      #   raise "Date is after maturity_date!" if date > @maturity_date
+      #   last = date
+      #   interest_payments(date).map do |payday|
+      #     interest = @coupon * @face_value * ((payday-last)/@days_of_year)
+      #     interest += @face_value if payday == @maturity_date
+      #     last = payday
+      #     interest / ((1+irr) ** ((payday-date)/@days_of_year))
+      #   end.inject(:+) / (1+fees)
+      # end
+
+      def price_for_irr(irr, date, ex_coupon_date: nil, fees: 0)
         raise "Date is after maturity_date!" if date > @maturity_date
-        last = date
-        interest_payments(date).map do |payday|
-          interest = @coupon * @face_value * ((payday-last)/@days_of_year)
-          interest += @face_value if payday == @maturity_date
-          last = payday
-          interest / ((1+irr) ** ((payday-date)/@days_of_year))
-        end.inject(:+) / (1+fees)
+        if date <= @start_date
+          date = @start_date
+        end
+        last_coupon_payday = @coupon_payment_dates.last
+        payment_dates = coupon_payments(date)
+        
+        if payment_dates.count == 0
+          # no more coupon payments, we do only 1 discount of accrued interest and face value to the current date
+          if is_365?
+            discount_factor = 1/(1+irr*(@maturity_date-date)/accrued_interest_discount_days)
+          else
+            discount_factor = 1/(1+irr*@coupon_frequency*day_count_factor(date, @maturity_date, nil))
+          end
+          discounted_accrued_interest = @coupon*@face_value*accrued_interest_factor*discount_factor
+          discounted_face_value = @face_value*discount_factor
+          price = discounted_accrued_interest + discounted_face_value
+        else
+          # we discount face value and coupons and accrued interest (coupon) at maturity (if any)
+          # to the first coupon payment left, and then discount the total to current date
+          value_at_first_coupon = 0
+          if payment_dates.include?(@maturity)
+            # last coupon payment is at maturity
+            discount_factor = 1/(1+irr)**(payment_dates.count-1)
+            value_at_first_coupon = @face_value*discount_factor
+          else
+            # last coupon is not at maturity, need to add accrued interest (coupon)
+            discount_factor = 1/((1+irr)**(payment_dates.count-1))/(1+irr*@coupon_frequency*accrued_interest_factor)
+            discounted_accrued_interest = @coupon*@face_value*accrued_interest_factor*discount_factor
+            discounted_face_value = @face_value*discount_factor
+            value_at_first_coupon = discounted_accrued_interest + discounted_face_value
+          end  
+
+          # first coupon can be pro-rata
+          value_at_first_coupon += first_coupon(date, ex_coupon_date)
+          if payment_dates.count > 1
+            for n in 1..payment_dates.count-1 do
+              value_at_first_coupon += @coupon*@face_value/@coupon_frequency/(1+irr)**n   
+            end
+          end
+
+          # discount value at first coupon date to present value
+          if is_365?
+            price = value_at_first_coupon/(1+irr*(payment_dates.first-date)/first_coupon_discount_days(date))/(1+fees)
+          else
+            price = value_at_first_coupon/(1+irr*@coupon_frequency*day_count_factor(date, payment_dates.first, nil))/(1+fees)
+          end   
+        end
+
+      end
+
+      def first_coupon(date, ex_coupon_date)
+        if !ex_coupon_date.nil? && date > ex_coupon_date
+          # after ex coupon date, buyer won't receive next coupon
+          return 0
+        end
+        
+        coupon = @coupon*@face_value/@coupon_frequency
+        if date <= @coupon_payment_dates.first
+          coupon = @coupon*@face_value*first_coupon_factor
+        end
+        coupon
+      end
+
+      def accrued_interest_discount_days
+        # the days between last coupon payment date and the next coupon payment date if maturity was longer
+        last_coupon_payday = @coupon_payment_dates.last
+        (add_month(last_coupon_payday, (12/@coupon_frequency).to_i) - last_coupon_payday).to_i
+      end
+
+      def first_coupon_discount_days(date)
+        # first coupon date is based on current date
+        payment_dates = coupon_payments(date)
+        first_coupon_date = payment_dates.first
+        (first_coupon_date - add_month(first_coupon_date, -(12/@coupon_frequency).to_i)).to_i
+      end
+
+      def first_coupon_factor
+        date1 = @start_date
+        date2 = @coupon_payment_dates.first
+        date3 = add_month(date2, -(12/@coupon_frequency).to_i)
+        if is_365?
+          (date2 - date1)/(date2 - date3)/@coupon_frequency
+        else
+          day_count_factor(date1, date2, date3)
+        end
+      end
+
+      def accrued_interest_factor
+        date1 = @coupon_payment_dates.last
+        date2 = @maturity_date
+        date3 = add_month(date1, (12/@coupon_frequency).to_i)
+        day_count_factor(date1, date2, date3)
       end
+
+      def day_count_factor(date1, date2, date3)
+        if is_365?
+          (date2 - date1)/(date3 - date1)/@coupon_frequency
+        else
+          d1 = [date1.day, 30].min
+          d2 = date2.day
+          if d1 == 30 
+            d2 = [d2, 30].min
+          end
+          (360*(date2.year - date1.year) + 30*(date2.month - date1.month) + d2 - d1)/360.to_d
+        end
+      end
+
     end
   end
 end

data/lib/istox/version.rb

@@ -1,3 +1,3 @@
 module Istox
-  VERSION = '0.1.83'.freeze
+  VERSION = '0.1.84'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: istox
 version: !ruby/object:Gem::Version
-  version: 0.1.83
+  version: 0.1.84
 platform: ruby
 authors:
 - Siong Leng