finrb 0.1.0 → 0.1.2

data/lib/finrb/utils.rb

@@ -5,9 +5,9 @@ require_relative 'decimal'
 require 'bigdecimal'
 require 'bigdecimal/newton'
 
-include Newton
-
 module Finrb
+  include Newton
+
   class Utils
     class NlFunctionStub
       attr_accessor :func
@@ -30,29 +30,27 @@ module Finrb
     # @param d the dollar discount, which is equal to the difference between the face value of the bill and the purchase price
     # @param f the face value (par value) of the bill
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # bdy(d=1500,f=100000,t=120)
+    # @example
+    #   Finrb::Utils.bdy(d=1500,f=100000,t=120)
     def self.bdy(d:, f:, t:)
-      d = d.to_d
-      f = f.to_d
-      t = t.to_d
+      d = Flt::DecNum(d.to_s)
+      f = Flt::DecNum(f.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      (360 * d / f / t)
+      (d * 360 / f / t)
     end
 
     # Computing money market yield (MMY) for a T-bill
     #
     # @param bdy bank discount yield
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # bdy2mmy(bdy=0.045,t=120)
+    # @example
+    #   Finrb::Utils.bdy2mmy(bdy=0.045,t=120)
     def self.bdy2mmy(bdy:, t:)
-      bdy = bdy.to_d
-      t = t.to_d
+      bdy = Flt::DecNum(bdy.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      (360 * bdy / (360 - (t * bdy)))
+      (bdy * 360 / (360 - (t * bdy)))
     end
 
     # cash ratio -- Liquidity ratios measure the firm's ability to satisfy its short-term obligations as they come due.
@@ -60,13 +58,12 @@ module Finrb
     # @param cash cash
     # @param ms   marketable securities
     # @param cl   current liabilities
-    # @export
-    # @examples
-    # Finrb::Utils.cash_ratio(cash=3000,ms=2000,cl=2000)
+    # @example
+    #   Finrb::Utils.cash_ratio(cash=3000,ms=2000,cl=2000)
     def self.cash_ratio(cash:, ms:, cl:)
-      cash = cash.to_d
-      ms = ms.to_d
-      cl = cl.to_d
+      cash = Flt::DecNum(cash.to_s)
+      ms = Flt::DecNum(ms.to_s)
+      cl = Flt::DecNum(cl.to_s)
 
       ((cash + ms) / cl)
     end
@@ -75,12 +72,11 @@ module Finrb
     #
     # @param sd standard deviation
     # @param avg average value
-    # @export
-    # @examples
-    # Finrb::Utils.coefficient_variation(sd=0.15,avg=0.39)
+    # @example
+    #   Finrb::Utils.coefficient_variation(sd=0.15,avg=0.39)
     def self.coefficient_variation(sd:, avg:)
-      sd = sd.to_d
-      avg = avg.to_d
+      sd = Flt::DecNum(sd.to_s)
+      avg = Flt::DecNum(avg.to_s)
 
       (sd / avg)
     end
@@ -88,71 +84,72 @@ module Finrb
     # Cost of goods sold and ending inventory under three methods (FIFO,LIFO,Weighted average)
     #
     # @param uinv units of beginning inventory
-    # @param pinv prince of beginning inventory
+    # @param pinv price of beginning inventory
     # @param units nx1 vector of inventory units. inventory purchased ordered by time (from first to last)
     # @param price nx1 vector of inventory price. same order as units
     # @param sinv units of sold inventory
     # @param method inventory methods: FIFO (first in first out, permitted under both US and IFRS), LIFO (late in first out, US only), WAC (weighted average cost,US and IFRS)
-    # @export
-    # @examples
-    # cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="FIFO")
+    # @example
+    #   Finrb::Utils.cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="FIFO")
     #
-    # cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="LIFO")
+    # @example
+    #   Finrb::Utils.cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="LIFO")
     #
-    # cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="WAC")
+    # @example
+    #   Finrb::Utils.cogs(uinv=2,pinv=2,units=[3,5],price=[3,5],sinv=7,method="WAC")
     def self.cogs(uinv:, pinv:, units:, price:, sinv:, method: 'FIFO')
-      uinv = uinv.to_d
-      pinv = pinv.to_d
-      units = Array.wrap(units).map(&:to_d)
-      price = Array.wrap(price).map(&:to_d)
-      sinv = sinv.to_d
+      uinv = Flt::DecNum(uinv.to_s)
+      pinv = Flt::DecNum(pinv.to_s)
+      units = Array.wrap(units).map { |value| Flt::DecNum(value.to_s) }
+      price = Array.wrap(price).map { |value| Flt::DecNum(value.to_s) }
+      sinv = Flt::DecNum(sinv.to_s)
       method = method.to_s
 
       n = units.size
       m = price.size
-      costOfGoods = 0
-      endingInventory = 0
+      cost_of_goods = 0
+      ending_inventory = 0
       if m == n
         case method
         when 'FIFO'
           if sinv <= uinv
-            costOfGoods = sinv * pinv
-            endingInventory = (uinv - sinv) * pinv
+            cost_of_goods = sinv * pinv
+            ending_inventory = (uinv - sinv) * pinv
             (0...n).each do |i|
-              endingInventory += (units[i] * price[i])
+              ending_inventory += (units[i] * price[i])
             end
           else
-            costOfGoods = uinv * pinv
+            cost_of_goods = uinv * pinv
             sinv -= uinv
             (0...n).each do |i|
               if sinv <= units[i]
-                costOfGoods += (sinv * price[i])
-                endingInventory = (units[i] - sinv) * price[i]
+                cost_of_goods += (sinv * price[i])
+                ending_inventory = (units[i] - sinv) * price[i]
                 if i < n
                   temp = i + 1
                   (temp...n).each do |j|
-                    endingInventory += (units[j] * price[j])
+                    ending_inventory += (units[j] * price[j])
                   end
                 end
                 sinv = 0
                 next
               else
-                costOfGoods += (units[i] * price[i])
+                cost_of_goods += (units[i] * price[i])
                 sinv -= units[i]
               end
             end
             raise(FinrbError, "Inventory is not enough to sell\n") if sinv.positive?
           end
         when 'WAC'
-          endingInventory = uinv * pinv
+          ending_inventory = uinv * pinv
           tu = uinv
           (0...n).each do |i|
-            endingInventory += (units[i] * price[i])
+            ending_inventory += (units[i] * price[i])
             tu += units[i]
           end
           if tu >= sinv
-            costOfGoods = endingInventory / tu * sinv
-            endingInventory = endingInventory / tu * (tu - sinv)
+            cost_of_goods = ending_inventory / tu * sinv
+            ending_inventory = ending_inventory / tu * (tu - sinv)
           else
             raise(FinrbError, "Inventory is not enough to sell\n")
           end
@@ -160,26 +157,26 @@ module Finrb
         when 'LIFO'
           (n - 1).downto(0).each do |i|
             if sinv <= units[i]
-              costOfGoods += (sinv * price[i])
-              endingInventory = (units[i] - sinv) * price[i]
+              cost_of_goods += (sinv * price[i])
+              ending_inventory = (units[i] - sinv) * price[i]
               if i > 1
                 temp = i - 1
                 temp.downto(0).each do |j|
-                  endingInventory += (units[j] * price[j])
+                  ending_inventory += (units[j] * price[j])
                 end
               end
-              endingInventory += (uinv * pinv)
+              ending_inventory += (uinv * pinv)
               sinv = 0
               next
             else
-              costOfGoods += (units[i] * price[i])
+              cost_of_goods += (units[i] * price[i])
               sinv -= units[i]
             end
           end
           if sinv.positive?
             if sinv <= uinv
-              costOfGoods += (sinv * pinv)
-              endingInventory += ((uinv - sinv) * pinv)
+              cost_of_goods += (sinv * pinv)
+              ending_inventory += ((uinv - sinv) * pinv)
             else
               raise(FinrbError, "Inventory is not enough to sell\n")
             end
@@ -190,19 +187,21 @@ module Finrb
         raise(FinrbError, "length of units and price are not the same\n")
       end
 
-      [costOfGoods, endingInventory]
+      {
+        cost_of_goods: cost_of_goods,
+        ending_inventory: ending_inventory
+      }
     end
 
     # current ratio -- Liquidity ratios measure the firm's ability to satisfy its short-term obligations as they come due.
     #
     # @param ca current assets
     # @param cl current liabilities
-    # @export
-    # @examples
-    # Finrb::Utils.current_ratio(ca=8000,cl=2000)
+    # @example
+    #   Finrb::Utils.current_ratio(ca=8000,cl=2000)
     def self.current_ratio(ca:, cl:)
-      ca = ca.to_d
-      cl = cl.to_d
+      ca = Flt::DecNum(ca.to_s)
+      cl = Flt::DecNum(cl.to_s)
 
       (ca / cl)
     end
@@ -212,24 +211,23 @@ module Finrb
     # @param cost cost of long-lived assets
     # @param rv   residual value of the long-lived assets at the end of its useful life. DDB does not explicitly use the asset's residual value in the calculations, but depreciation ends once the estimated residual value has been reached. If the asset is expected to have no residual value, the DB method will never fully depreciate it, so the DB method is typically changed to straight-line at some point in the asset's life.
     # @param t    length of the useful life
-    # @export
-    # @examples
-    # ddb(cost=1200,rv=200,t=5)
+    # @example
+    #   Finrb::Utils.ddb(cost=1200,rv=200,t=5)
     def self.ddb(cost:, rv:, t:)
-      cost = cost.to_d
-      rv = rv.to_d
-      t = t.to_d
+      cost = Flt::DecNum(cost.to_s)
+      rv = Flt::DecNum(rv.to_s)
+      t = Flt::DecNum(t.to_s)
 
       raise(FinrbError, 't should be larger than 1') if t < 2
 
       ddb = [0] * t
-      ddb[0] = 2 * cost / t
+      ddb[0] = cost * 2 / t
       if cost - ddb[0] <= rv
         ddb[0] = cost - rv
       else
         cost -= ddb[0]
         (1...t).each do |i|
-          ddb[i] = 2 * cost / t
+          ddb[i] = cost * 2 / t
           if cost - ddb[i] <= rv
             ddb[i] = cost - rv
             break
@@ -238,19 +236,18 @@ module Finrb
           end
         end
       end
-      { t: (0...t).to_a, ddb: }
+      { t: (0...t).to_a, ddb: ddb }
     end
 
     # debt ratio -- Solvency ratios measure the firm's ability to satisfy its long-term obligations.
     #
     # @param td total debt
     # @param ta total assets
-    # @export
-    # @examples
-    # Finrb::Utils.debt_ratio(td=6000,ta=20000)
+    # @example
+    #   Finrb::Utils.debt_ratio(td=6000,ta=20000)
     def self.debt_ratio(td:, ta:)
-      td = td.to_d
-      ta = ta.to_d
+      td = Flt::DecNum(td.to_s)
+      ta = Flt::DecNum(ta.to_s)
 
       (td / ta)
     end
@@ -266,25 +263,27 @@ module Finrb
     # @param cps    shares from conversion of convertible preferred stock
     # @param cds    shares from conversion of convertible debt
     # @param iss    shares issuable from stock options
-    # @export
-    # @examples
-    # Finrb::Utils.diluted_eps(ni=115600,pd=10000,cdi=42000,tax=0.4,w=200000,cds=60000)
+    # @example
+    #   Finrb::Utils.diluted_eps(ni=115600,pd=10000,cdi=42000,tax=0.4,w=200000,cds=60000)
     #
-    # Finrb::Utils.diluted_eps(ni=115600,pd=10000,cpd=10000,w=200000,cps=40000)
+    # @example
+    #   Finrb::Utils.diluted_eps(ni=115600,pd=10000,cpd=10000,w=200000,cps=40000)
     #
-    # Finrb::Utils.diluted_eps(ni=115600,pd=10000,w=200000,iss=2500)
+    # @example
+    #   Finrb::Utils.diluted_eps(ni=115600,pd=10000,w=200000,iss=2500)
     #
-    # Finrb::Utils.diluted_eps(ni=115600,pd=10000,cpd=10000,cdi=42000,tax=0.4,w=200000,cps=40000,cds=60000,iss=2500)
+    # @example
+    #   Finrb::Utils.diluted_eps(ni=115600,pd=10000,cpd=10000,cdi=42000,tax=0.4,w=200000,cps=40000,cds=60000,iss=2500)
     def self.diluted_eps(ni:, pd:, w:, cpd: 0, cdi: 0, tax: 0, cps: 0, cds: 0, iss: 0)
-      ni = ni.to_d
-      pd = pd.to_d
-      w = w.to_d
-      cpd = cpd.to_d
-      cdi = cdi.to_d
-      tax = tax.to_d
-      cps = cps.to_d
-      cds = cds.to_d
-      iss = iss.to_d
+      ni = Flt::DecNum(ni.to_s)
+      pd = Flt::DecNum(pd.to_s)
+      w = Flt::DecNum(w.to_s)
+      cpd = Flt::DecNum(cpd.to_s)
+      cdi = Flt::DecNum(cdi.to_s)
+      tax = Flt::DecNum(tax.to_s)
+      cps = Flt::DecNum(cps.to_s)
+      cds = Flt::DecNum(cds.to_s)
+      iss = Flt::DecNum(iss.to_s)
 
       basic = (ni - pd) / w
       diluted = (ni - pd + cpd + (cdi * (1 - tax))) / (w + cps + cds + iss)
@@ -301,23 +300,21 @@ module Finrb
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
     # @param lower the lower end points of the rate of return to be searched.
     # @param upper the upper end points of the rate of return to be searched.
-    # @importFrom stats uniroot
-    # @export
-    # @examples
-    # Finrb::Utils.discount_rate(n=5,pv=0,fv=600,pmt=-100,type=0)
+    # @example
+    #   Finrb::Utils.discount_rate(n=5,pv=0,fv=600,pmt=-100,type=0)
     def self.discount_rate(n:, pv:, fv:, pmt:, type: 0, lower: 0.0001, upper: 100)
-      n = n.to_d
-      pv = pv.to_d
-      fv = fv.to_d
-      pmt = pmt.to_d
-      type = type.to_d
-      lower = lower.to_d
-      upper = upper.to_d
+      n = Flt::DecNum(n.to_s)
+      pv = Flt::DecNum(pv.to_s)
+      fv = Flt::DecNum(fv.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
+      lower = Flt::DecNum(lower.to_s)
+      upper = Flt::DecNum(upper.to_s)
 
       nlfunc = NlFunctionStub.new
       nlfunc.func =
         lambda do |x|
-          BigDecimal((Finrb::Utils.fv_simple(x[0], n, pv) + Finrb::Utils.fv_annuity(x[0], n, pmt, type) - fv).to_s)
+          [BigDecimal((Finrb::Utils.fv_simple(r: x[0], n: n, pv: pv) + Finrb::Utils.fv_annuity(r: x[0], n: n, pmt: pmt, type: type) - fv).to_s)]
         end
 
       root = [(upper - lower) / 2]
@@ -329,97 +326,100 @@ module Finrb
     #
     # @param r stated annual rate
     # @param m number of compounding periods per year
-    # @export
-    # @examples
-    # ear(r=0.12,m=12)
+    # @example
+    #   Finrb::Utils.ear(r=0.12,m=12)
     #
-    # ear(0.04,365)
+    # @example
+    #   Finrb::Utils.ear(0.04,365)
     def self.ear(r:, m:)
-      r = r.to_d
-      m = m.to_d
+      r = Flt::DecNum(r.to_s)
+      m = Flt::DecNum(m.to_s)
 
-      (((1 + (r / m))**m) - 1)
+      ((((r / m) + 1)**m) - 1)
     end
 
     # Convert stated annual rate to the effective annual rate with continuous compounding
     #
     # @param r stated annual rate
-    # @export
-    # @examples
-    # Finrb::Utils.ear_continuous(r=0.1)
+    # @example
+    #   Finrb::Utils.ear_continuous(r=0.1)
     #
-    # Finrb::Utils.ear_continuous(0.03)
+    # @example
+    #   Finrb::Utils.ear_continuous(0.03)
     def self.ear_continuous(r:)
-      r = r.to_d
+      r = Flt::DecNum(r.to_s)
 
-      (r.to_d.exp - 1)
+      (r.to_dec.exp - 1)
     end
 
     # bond-equivalent yield (BEY), 2 x the semiannual discount rate
     #
     # @param ear effective annual rate
-    # @export
-    # @examples
-    # ear2bey(ear=0.08)
+    # @example
+    #   Finrb::Utils.ear2bey(ear=0.08)
     def self.ear2bey(ear:)
-      ear = ear.to_d
+      ear = Flt::DecNum(ear.to_s)
 
-      ((((1 + ear)**0.5) - 1) * 2)
+      ((((ear + 1)**0.5) - 1) * 2)
     end
 
     # Computing HPR, the holding period return
     #
     # @param ear effective annual rate
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # ear2hpr(ear=0.05039,t=150)
+    # @example
+    #   Finrb::Utils.ear2hpr(ear=0.05039,t=150)
     def self.ear2hpr(ear:, t:)
-      ear = ear.to_d
-      t = t.to_d
+      ear = Flt::DecNum(ear.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      (((1 + ear)**(t / 365)) - 1)
+      (((ear + 1)**(t / 365)) - 1)
     end
 
     # Equivalent/proportional Interest Rates
-    # @description An interest rate to be applied n times p.a. can be converted to an equivalent rate to be applied p times p.a.
+    # @note An interest rate to be applied n times p.a. can be converted to an equivalent rate to be applied p times p.a.
     # @param r interest rate to be applied n times per year (r is annual rate!)
     # @param n times that the interest rate r were compounded per year
     # @param p times that the equivalent rate were compounded per year
     # @param type equivalent interest rates ('e',default) or proportional interest rates ('p')
-    # @export
-    # @examples
-    # # monthly interest rat equivalent to 5% compounded per year
-    # Finrb::Utils.eir(r=0.05,n=1,p=12)
-    #
-    # # monthly interest rat equivalent to 5% compounded per half year
-    # Finrb::Utils.eir(r=0.05,n=2,p=12)
-    #
-    # # monthly interest rat equivalent to 5% compounded per quarter
-    # Finrb::Utils.eir(r=0.05,n=4,p=12)
-    #
-    # # annual interest rate equivalent to 5% compounded per month
-    # Finrb::Utils.eir(r=0.05,n=12,p=1)
-    # # this is equivalent to
-    # ear(r=0.05,m=12)
-    #
-    # # quarter interest rate equivalent to 5% compounded per year
-    # Finrb::Utils.eir(r=0.05,n=1,p=4)
-    #
-    # # quarter interest rate equivalent to 5% compounded per month
-    # Finrb::Utils.eir(r=0.05,n=12,p=4)
-    #
-    # # monthly proportional interest rate which is equivalent to a simple annual interest
-    # Finrb::Utils.eir(r=0.05,p=12,type='p')
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per year
+    #   Finrb::Utils.eir(r=0.05,n=1,p=12)
+    #
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per half year
+    #   Finrb::Utils.eir(r=0.05,n=2,p=12)
+    #
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per quarter
+    #   Finrb::Utils.eir(r=0.05,n=4,p=12)
+    #
+    # @example
+    #   # annual interest rate equivalent to 5% compounded per month
+    #   Finrb::Utils.eir(r=0.05,n=12,p=1)
+    #   # this is equivalent to
+    #   Finrb::Utils.ear(r=0.05,m=12)
+    #
+    # @example
+    #   # quarter interest rate equivalent to 5% compounded per year
+    #   Finrb::Utils.eir(r=0.05,n=1,p=4)
+    #
+    # @example
+    #   # quarter interest rate equivalent to 5% compounded per month
+    #   Finrb::Utils.eir(r=0.05,n=12,p=4)
+    #
+    # @example
+    #   # monthly proportional interest rate which is equivalent to a simple annual interest
+    #   Finrb::Utils.eir(r=0.05,p=12,type='p')
     def self.eir(r:, n: 1, p: 12, type: 'e')
-      r = r.to_d
-      n = n.to_d
-      p = p.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      p = Flt::DecNum(p.to_s)
       type = type.to_s
 
       case type
       when 'e'
-        eir = ((1 + (r / n))**(n / p)) - 1
+        eir = (((r / n) + 1)**(n / p)) - 1
       when 'p'
         eir = r / p
       else
@@ -433,13 +433,12 @@ module Finrb
     # @param ni net income
     # @param pd preferred dividends
     # @param w  weighted average number of common shares outstanding
-    # @export
-    # @examples
-    # Finrb::Utils.eps(ni=10000,pd=1000,w=11000)
+    # @example
+    #   Finrb::Utils.eps(ni=10000,pd=1000,w=11000)
     def self.eps(ni:, pd:, w:)
-      ni = ni.to_d
-      pd = pd.to_d
-      w = w.to_d
+      ni = Flt::DecNum(ni.to_s)
+      pd = Flt::DecNum(pd.to_s)
+      w = Flt::DecNum(w.to_s)
 
       ((ni - pd) / w)
     end
@@ -448,12 +447,11 @@ module Finrb
     #
     # @param te total equity
     # @param ta total assets
-    # @export
-    # @examples
-    # Finrb::Utils.financial_leverage(te=16000,ta=20000)
+    # @example
+    #   Finrb::Utils.financial_leverage(te=16000,ta=20000)
     def self.financial_leverage(te:, ta:)
-      te = te.to_d
-      ta = ta.to_d
+      te = Flt::DecNum(te.to_s)
+      ta = Flt::DecNum(ta.to_s)
 
       (ta / te)
     end
@@ -465,20 +463,19 @@ module Finrb
     # @param pv present value
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # fv(r=0.07,n=10,pv=1000,pmt=10)
+    # @example
+    #   Finrb::Utils.fv(r=0.07,n=10,pv=1000,pmt=10)
     def self.fv(r:, n:, pv: 0, pmt: 0, type: 0)
-      r = r.to_d
-      n = n.to_d
-      pv = pv.to_d
-      pmt = pmt.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      pv = Flt::DecNum(pv.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        (Finrb::Utils.fv_simple(r, n, pv) + Finrb::Utils.fv_annuity(r, n, pmt, type))
+        (Finrb::Utils.fv_simple(r: r, n: n, pv: pv) + Finrb::Utils.fv_annuity(r: r, n: n, pmt: pmt, type: type))
       end
     end
 
@@ -488,21 +485,21 @@ module Finrb
     # @param n number of periods
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # Finrb::Utils.fv_annuity(0.03,12,-1000)
+    # @example
+    #   Finrb::Utils.fv_annuity(0.03,12,-1000)
     #
-    # Finrb::Utils.fv_annuity(r=0.03,n=12,pmt=-1000,type=1)
+    # @example
+    #   Finrb::Utils.fv_annuity(r=0.03,n=12,pmt=-1000,type=1)
     def self.fv_annuity(r:, n:, pmt:, type: 0)
-      r = r.to_d
-      n = n.to_d
-      pmt = pmt.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        (pmt / r * (((1 + r)**n) - 1)) * ((1 + r)**type) * -1
+        (pmt / r * (((r + 1)**n) - 1)) * ((r + 1)**type) * -1
 
       end
     end
@@ -512,35 +509,34 @@ module Finrb
     # @param r discount rate, or the interest rate at which the amount will be compounded each period
     # @param n number of periods
     # @param pv present value
-    # @export
-    # @examples
-    # Finrb::Utils.fv_simple(0.08,10,-300)
+    # @example
+    #   Finrb::Utils.fv_simple(0.08,10,-300)
     #
-    # Finrb::Utils.fv_simple(r=0.04,n=20,pv=-50000)
+    # @example
+    #   Finrb::Utils.fv_simple(r=0.04,n=20,pv=-50000)
     def self.fv_simple(r:, n:, pv:)
-      r = r.to_d
-      n = n.to_d
-      pv = pv.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      pv = Flt::DecNum(pv.to_s)
 
-      ((pv * ((1 + r)**n)) * -1)
+      ((pv * ((r + 1)**n)) * -1)
     end
 
     # Computing the future value of an uneven cash flow series
     #
     # @param r stated annual rate
     # @param cf uneven cash flow
-    # @export
-    # @examples
-    # Finrb::Utils.fv_uneven(r=0.1, cf=[-1000, -500, 0, 4000, 3500, 2000])
+    # @example
+    #   Finrb::Utils.fv_uneven(r=0.1, cf=[-1000, -500, 0, 4000, 3500, 2000])
     def self.fv_uneven(r:, cf:)
-      r = r.to_d
-      cf = Array.wrap(cf).map(&:to_d)
+      r = Flt::DecNum(r.to_s)
+      cf = Array.wrap(cf).map { |value| Flt::DecNum(value.to_s) }
 
       m = cf.size
       sum = 0
       (0...m).each do |i|
-        n = m - i
-        sum += Finrb::Utils.fv_simple(r, n, cf[i])
+        n = m - (i + 1)
+        sum += Finrb::Utils.fv_simple(r: r, n: n, pv: cf[i])
       end
       sum
     end
@@ -548,39 +544,36 @@ module Finrb
     # Geometric mean return
     #
     # @param r returns over multiple periods
-    # @export
-    # @examples
-    # Finrb::Utils.geometric_mean(r=[-0.0934, 0.2345, 0.0892])
+    # @example
+    #   Finrb::Utils.geometric_mean(r=[-0.0934, 0.2345, 0.0892])
     def self.geometric_mean(r:)
-      r = Array.wrap(r).map(&:to_d)
+      r = Array.wrap(r).map { |value| Flt::DecNum(value.to_s) }
 
-      rs = r + 1
-      ((rs.reduce(:*)**(1 / rs.size)) - 1)
+      rs = r.map { |value| value + 1 }
+      ((rs.reduce(:*)**(1.to_f / rs.size)) - 1)
     end
 
     # gross profit margin -- Evaluate a company's financial performance
     #
     # @param gp gross profit, equal to revenue minus cost of goods sold (cogs)
     # @param rv revenue (sales)
-    # @export
-    # @examples
-    # gpm(gp=1000,rv=20000)
+    # @example
+    #   Finrb::Utils.gpm(gp=1000,rv=20000)
     def self.gpm(gp:, rv:)
-      gp = gp.to_d
-      rv = rv.to_d
+      gp = Flt::DecNum(gp.to_s)
+      rv = Flt::DecNum(rv.to_s)
 
       (gp / rv)
     end
 
     # harmonic mean, average price
     # @param p price over multiple periods
-    # @export
-    # @examples
-    # Finrb::Utils.harmonic_mean(p=[8,9,10])
+    # @example
+    #   Finrb::Utils.harmonic_mean(p=[8,9,10])
     def self.harmonic_mean(p:)
-      p = Array.wrap(p).map(&:to_d)
+      p = Array.wrap(p).map { |value| Flt::DecNum(value.to_s) }
 
-      (1 / (p.sum { |val| 1 / val } / p.size))
+      (1.to_f / (p.sum { |val| 1.to_f / val } / p.size))
     end
 
     # Computing HPR, the holding period return
@@ -588,13 +581,12 @@ module Finrb
     # @param ev ending value
     # @param bv beginning value
     # @param cfr cash flow received
-    # @export
-    # @examples
-    # hpr(ev=33,bv=30,cfr=0.5)
+    # @example
+    #   Finrb::Utils.hpr(ev=33,bv=30,cfr=0.5)
     def self.hpr(ev:, bv:, cfr: 0)
-      ev = ev.to_d
-      bv = bv.to_d
-      cfr = cfr.to_d
+      ev = Flt::DecNum(ev.to_s)
+      bv = Flt::DecNum(bv.to_s)
+      cfr = Flt::DecNum(cfr.to_s)
 
       ((ev - bv + cfr) / bv)
     end
@@ -603,60 +595,54 @@ module Finrb
     #
     # @param hpr holding period return
     # @param t number of month remaining until maturity
-    # @export
-    # @examples
-    # hpr2bey(hpr=0.02,t=3)
+    # @example
+    #   Finrb::Utils.hpr2bey(hpr=0.02,t=3)
     def self.hpr2bey(hpr:, t:)
-      hpr = hpr.to_d
-      t = t.to_d
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      ((((1 + hpr)**(6 / t)) - 1) * 2)
+      ((((hpr + 1)**(6 / t)) - 1) * 2)
     end
 
     # Convert holding period return to the effective annual rate
     #
     # @param hpr holding period return
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # hpr2ear(hpr=0.015228,t=120)
+    # @example
+    #   Finrb::Utils.hpr2ear(hpr=0.015228,t=120)
     def self.hpr2ear(hpr:, t:)
-      hpr = hpr.to_d
-      t = t.to_d
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      (((1 + hpr)**(365 / t)) - 1)
+      (((hpr + 1)**(365 / t)) - 1)
     end
 
     # Computing money market yield (MMY) for a T-bill
     #
     # @param hpr holding period return
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # hpr2mmy(hpr=0.01523,t=120)
+    # @example
+    #   Finrb::Utils.hpr2mmy(hpr=0.01523,t=120)
     def self.hpr2mmy(hpr:, t:)
-      hpr = hpr.to_d
-      t = t.to_d
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
 
-      (360 * hpr / t)
+      (hpr * 360 / t)
     end
 
     # Computing IRR, the internal rate of return
     #
     # @param cf cash flow,the first cash flow is the initial outlay
-    # @importFrom stats uniroot
-    # @export
-    # @examples
-    # irr(cf=[-5, 1.6, 2.4, 2.8])
+    # @example
+    #   Finrb::Utils.irr(cf=[-5, 1.6, 2.4, 2.8])
     def self.irr(cf:)
-      cf = Array.wrap(cf).map(&:to_d)
+      cf = Array.wrap(cf).map { |value| Flt::DecNum(value.to_s) }
 
-      n = cf.size
       subcf = cf.drop(1)
       nlfunc = NlFunctionStub.new
       nlfunc.func =
         lambda do |x|
-          BigDecimal(((-1 * Finrb::Utils.pv_uneven(x[0], subcf)) + cf[0]).to_s)
+          [BigDecimal(((Finrb::Utils.pv_uneven(r: x[0], cf: subcf) * -1) + cf[0]).to_s)]
         end
 
       root = [0]
@@ -664,61 +650,17 @@ module Finrb
       root[0]
     end
 
-    # Computing IRR, the internal rate of return
-    # @description This function is the same as irr but can calculate negative value. This function may take a very long time. You can use larger cutoff and larger step to get a less precision irr first. Then based on the result, change from and to, to narrow down the interval, and use a smaller step to get a more precision irr.
-    # @param cf cash flow,the first cash flow is the initial outlay
-    # @param cutoff threshold to take npv as zero
-    # @param from smallest irr to try
-    # @param to largest irr to try
-    # @param step increment of the irr
-    # @export
-    # @examples
-    # irr2(cf=[-5, 1.6, 2.4, 2.8])
-    # irr2(cf=[-200, 50, 60, -70, 30, 20])
-    def self.irr2(cf:, cutoff: 0.1, from: -1, to: 10, step: 0.000001)
-      cf = Array.wrap(cf).map(&:to_d)
-      cutoff = cutoff.to_d
-      from = from.to_d
-      to = to.to_d
-      step = step.to_d
-
-      r0 = nil
-      n = cf.size
-      from.step((to - 1), step).each do |r|
-        npv = cf[0]
-        (1...n).each do |i|
-          npv += (cf[i] / ((1 + r)**(i - 1)))
-        end
-        next if npv.nil?
-
-        if npv.abs < cutoff
-          r0 = r
-          break
-        end
-      end
-
-      if r0.nil?
-        raise(
-          FinrbError,
-          'can not find irr in the given interval, you can try smaller step, and/or larger to, and/or larger cutoff'
-        )
-      end
-
-      r0
-    end
-
     # calculate the net increase in common shares from the potential exercise of stock options or warrants
     #
     # @param amp average market price over the year
     # @param ep  exercise price of the options or warrants
     # @param n   number of common shares that the options and warrants can be convened into
-    # @export
-    # @examples
-    # iss(amp=20,ep=15,n=10000)
+    # @example
+    #   Finrb::Utils.iss(amp=20,ep=15,n=10000)
     def self.iss(amp:, ep:, n:)
-      amp = amp.to_d
-      ep = ep.to_d
-      n = n.to_d
+      amp = Flt::DecNum(amp.to_s)
+      ep = Flt::DecNum(ep.to_s)
+      n = Flt::DecNum(n.to_s)
 
       if amp > ep
         ((amp - ep) * n / amp)
@@ -731,12 +673,11 @@ module Finrb
     #
     # @param ltd long-term debt
     # @param te  total equity
-    # @export
-    # @examples
-    # Finrb::Utils.lt_d2e(ltd=8000,te=20000)
+    # @example
+    #   Finrb::Utils.lt_d2e(ltd=8000,te=20000)
     def self.lt_d2e(ltd:, te:)
-      ltd = ltd.to_d
-      te = te.to_d
+      ltd = Flt::DecNum(ltd.to_s)
+      te = Flt::DecNum(te.to_s)
 
       (ltd / te)
     end
@@ -745,12 +686,11 @@ module Finrb
     #
     # @param mmy money market yield
     # @param t number of days remaining until maturity
-    # @export
-    # @examples
-    # mmy2hpr(mmy=0.04898,t=150)
+    # @example
+    #   Finrb::Utils.mmy2hpr(mmy=0.04898,t=150)
     def self.mmy2hpr(mmy:, t:)
-      mmy = mmy.to_d
-      t = t.to_d
+      mmy = Flt::DecNum(mmy.to_s)
+      t = Flt::DecNum(t.to_s)
 
       (mmy * t / 360)
     end
@@ -762,22 +702,22 @@ module Finrb
     # @param fv future value
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # Finrb::Utils.n_period(0.1,-10000,60000000,-50000,0)
+    # @example
+    #   Finrb::Utils.n_period(0.1,-10000,60000000,-50000,0)
     #
-    # Finrb::Utils.n_period(r=0.1,pv=-10000,fv=60000000,pmt=-50000,type=1)
+    # @example
+    #   Finrb::Utils.n_period(r=0.1,pv=-10000,fv=60000000,pmt=-50000,type=1)
     def self.n_period(r:, pv:, fv:, pmt:, type: 0)
-      r = r.to_d
-      pv = pv.to_d
-      fv = fv.to_d
-      pmt = pmt.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      pv = Flt::DecNum(pv.to_s)
+      fv = Flt::DecNum(fv.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        (-1 * ((fv * r) - (pmt * ((1 + r)**type))) / ((pv * r) + (pmt * ((1 + r)**type)))).to_d.log / (1 + r).to_d.log
+        (((fv * r) - (pmt * ((r + 1)**type))) * -1 / ((pv * r) + (pmt * ((r + 1)**type)))).to_dec.log / (r + 1).to_dec.log
 
       end
     end
@@ -786,12 +726,11 @@ module Finrb
     #
     # @param ni net income
     # @param rv revenue (sales)
-    # @export
-    # @examples
-    # npm(ni=8000,rv=20000)
+    # @example
+    #   Finrb::Utils.npm(ni=8000,rv=20000)
     def self.npm(ni:, rv:)
-      ni = ni.to_d
-      rv = rv.to_d
+      ni = Flt::DecNum(ni.to_s)
+      rv = Flt::DecNum(rv.to_s)
 
       (ni / rv)
     end
@@ -800,16 +739,14 @@ module Finrb
     #
     # @param r discount rate, or the interest rate at which the amount will be compounded each period
     # @param cf cash flow,the first cash flow is the initial outlay
-    # @export
-    # @examples
-    # npv(r=0.12, cf=[-5, 1.6, 2.4, 2.8])
+    # @example
+    #   Finrb::Utils.npv(r=0.12, cf=[-5, 1.6, 2.4, 2.8])
     def self.npv(r:, cf:)
-      r = r.to_d
-      cf = Array.wrap(cf).map(&:to_d)
+      r = Flt::DecNum(r.to_s)
+      cf = Array.wrap(cf).map { |value| Flt::DecNum(value.to_s) }
 
-      n = cf.size
       subcf = cf.drop(1)
-      ((-1 * Finrb::Utils.pv_uneven(r, subcf)) + cf[0])
+      ((Finrb::Utils.pv_uneven(r: r, cf: subcf) * -1) + cf[0])
     end
 
     # Estimate period payment
@@ -819,25 +756,25 @@ module Finrb
     # @param pv present value
     # @param fv future value
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # pmt(0.08,10,-1000,10)
+    # @example
+    #   Finrb::Utils.pmt(0.08,10,-1000,10)
     #
-    # pmt(r=0.08,n=10,pv=-1000,fv=0)
+    # @example
+    #   Finrb::Utils.pmt(r=0.08,n=10,pv=-1000,fv=0)
     #
-    # pmt(0.08,10,-1000,10,1)
+    # @example
+    #   Finrb::Utils.pmt(0.08,10,-1000,10,1)
     def self.pmt(r:, n:, pv:, fv:, type: 0)
-      r = r.to_d
-      n = n.to_d
-      pv = pv.to_d
-      fv = fv.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      pv = Flt::DecNum(pv.to_s)
+      fv = Flt::DecNum(fv.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        (pv + (fv / ((1 + r)**n))) * r / (1 - (1 / ((1 + r)**n))) * -1 * ((1 + r)**(-1 * type))
-
+        (pv + (fv / ((r + 1)**n))) * r / (1 - (1.to_f / ((r + 1)**n))) * -1 * ((r + 1)**(type * -1))
       end
     end
 
@@ -848,22 +785,22 @@ module Finrb
     # @param fv future value
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # pv(0.07,10,1000,10)
+    # @example
+    #   Finrb::Utils.pv(0.07,10,1000,10)
     #
-    # pv(r=0.05,n=20,fv=1000,pmt=10,type=1)
+    # @example
+    #   Finrb::Utils.pv(r=0.05,n=20,fv=1000,pmt=10,type=1)
     def self.pv(r:, n:, fv: 0, pmt: 0, type: 0)
-      r = r.to_d
-      n = n.to_d
-      fv = fv.to_d
-      pmt = pmt.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      fv = Flt::DecNum(fv.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        Finrb::Utils.pv_simple(r, n, fv) + Finrb::Utils.pv_annuity(r, n, pmt, type)
+        Finrb::Utils.pv_simple(r: r, n: n, fv: fv) + Finrb::Utils.pv_annuity(r: r, n: n, pmt: pmt, type: type)
 
       end
     end
@@ -874,21 +811,21 @@ module Finrb
     # @param n number of periods
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # Finrb::Utils.pv_annuity(0.03,12,1000)
+    # @example
+    #   Finrb::Utils.pv_annuity(0.03,12,1000)
     #
-    # Finrb::Utils.pv_annuity(r=0.0425,n=3,pmt=30000)
+    # @example
+    #   Finrb::Utils.pv_annuity(r=0.0425,n=3,pmt=30000)
     def self.pv_annuity(r:, n:, pmt:, type: 0)
-      r = r.to_d
-      n = n.to_d
-      pmt = pmt.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       else
-        (pmt / r * (1 - (1 / ((1 + r)**n)))) * ((1 + r)**type) * -1
+        (pmt / r * (1 - (1.to_f / ((r + 1)**n)))) * ((r + 1)**type) * -1
 
       end
     end
@@ -899,25 +836,26 @@ module Finrb
     # @param g growth rate of perpetuity
     # @param pmt payment per period
     # @param type payments occur at the end of each period (type=0); payments occur at the beginning of each period (type=1)
-    # @export
-    # @examples
-    # Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000,g=0.02)
+    # @example
+    #   Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000,g=0.02)
     #
-    # Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000,type=1)
+    # @example
+    #   Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000,type=1)
     #
-    # Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000)
+    # @example
+    #   Finrb::Utils.pv_perpetuity(r=0.1,pmt=1000)
     def self.pv_perpetuity(r:, pmt:, g: 0, type: 0)
-      r = r.to_d
-      pmt = pmt.to_d
-      g = g.to_d
-      type = type.to_d
+      r = Flt::DecNum(r.to_s)
+      pmt = Flt::DecNum(pmt.to_s)
+      g = Flt::DecNum(g.to_s)
+      type = Flt::DecNum(type.to_s)
 
       if type != 0 && type != 1
         raise(FinrbError, 'Error: type should be 0 or 1!')
       elsif g >= r
         raise(FinrbError, 'Error: g is not smaller than r!')
       else
-        (pmt / (r - g)) * ((1 + r)**type) * -1
+        (pmt / (r - g)) * ((r + 1)**type) * -1
 
       end
     end
@@ -927,34 +865,33 @@ module Finrb
     # @param r discount rate, or the interest rate at which the amount will be compounded each period
     # @param n number of periods
     # @param fv future value
-    # @export
-    # @examples
-    # Finrb::Utils.pv_simple(0.07,10,100)
+    # @example
+    #   Finrb::Utils.pv_simple(0.07,10,100)
     #
-    # Finrb::Utils.pv_simple(r=0.03,n=3,fv=1000)
+    # @example
+    #   Finrb::Utils.pv_simple(r=0.03,n=3,fv=1000)
     def self.pv_simple(r:, n:, fv:)
-      r = r.to_d
-      n = n.to_d
-      fv = fv.to_d
+      r = Flt::DecNum(r.to_s)
+      n = Flt::DecNum(n.to_s)
+      fv = Flt::DecNum(fv.to_s)
 
-      ((fv / ((1 + r)**n)) * -1)
+      ((fv / ((r + 1)**n)) * -1)
     end
 
     # Computing the present value of an uneven cash flow series
     #
     # @param r discount rate, or the interest rate at which the amount will be compounded each period
     # @param cf uneven cash flow
-    # @export
-    # @examples
-    # Finrb::Utils.pv_uneven(r=0.1, cf=[-1000, -500, 0, 4000, 3500, 2000])
+    # @example
+    #   Finrb::Utils.pv_uneven(r=0.1, cf=[-1000, -500, 0, 4000, 3500, 2000])
     def self.pv_uneven(r:, cf:)
-      r = r.to_d
-      cf = Array.wrap(cf).map(&:to_d)
+      r = Flt::DecNum(r.to_s)
+      cf = Array.wrap(cf).map { |value| Flt::DecNum(value.to_s) }
 
       n = cf.size
       sum = 0
       (0...n).each do |i|
-        sum += Finrb::Utils.pv_simple(r, i, cf[i])
+        sum += Finrb::Utils.pv_simple(r: r, n: i + 1, fv: cf[i])
       end
       sum
     end
@@ -965,14 +902,13 @@ module Finrb
     # @param ms   marketable securities
     # @param rc   receivables
     # @param cl   current liabilities
-    # @export
-    # @examples
-    # Finrb::Utils.quick_ratio(cash=3000,ms=2000,rc=1000,cl=2000)
+    # @example
+    #   Finrb::Utils.quick_ratio(cash=3000,ms=2000,rc=1000,cl=2000)
     def self.quick_ratio(cash:, ms:, rc:, cl:)
-      cash = cash.to_d
-      ms = ms.to_d
-      rc = rc.to_d
-      cl = cl.to_d
+      cash = Flt::DecNum(cash.to_s)
+      ms = Flt::DecNum(ms.to_s)
+      rc = Flt::DecNum(rc.to_s)
+      cl = Flt::DecNum(cl.to_s)
 
       ((cash + ms + rc) / cl)
     end
@@ -981,56 +917,53 @@ module Finrb
     #
     # @param r norminal rate
     # @param m number of times compounded each year
-    # @export
-    # @examples
-    # Finrb::Utils.r_continuous(r=0.03,m=4)
+    # @example
+    #   Finrb::Utils.r_continuous(r=0.03,m=4)
     def self.r_continuous(r:, m:)
-      r = r.to_d
-      m = m.to_d
+      r = Flt::DecNum(r.to_s)
+      m = Flt::DecNum(m.to_s)
 
-      (m * (1 + (r / m)).to_d.log)
+      (m * ((r / m) + 1).to_dec.log)
     end
 
     # Convert a given continuous compounded rate to a norminal rate
     #
     # @param rc continuous compounded rate
     # @param m number of desired times compounded each year
-    # @export
-    # @examples
-    # Finrb::Utils.r_norminal(0.03,1)
+    # @example
+    #   Finrb::Utils.r_norminal(0.03,1)
     #
-    # Finrb::Utils.r_norminal(rc=0.03,m=4)
+    # @example
+    #   Finrb::Utils.r_norminal(rc=0.03,m=4)
     def self.r_norminal(rc:, m:)
-      rc = rc.to_d
-      m = m.to_d
+      rc = Flt::DecNum(rc.to_s)
+      m = Flt::DecNum(m.to_s)
 
-      (m * ((rc / m).to_d.exp - 1))
+      (m * ((rc / m).to_dec.exp - 1))
     end
 
     # Rate of return for a perpetuity
     #
     # @param pmt payment per period
     # @param pv present value
-    # @export
-    # @examples
-    # Finrb::Utils.r_perpetuity(pmt=4.5,pv=-75)
+    # @example
+    #   Finrb::Utils.r_perpetuity(pmt=4.5,pv=-75)
     def self.r_perpetuity(pmt:, pv:)
-      pmt = pmt.to_d
-      pv = pv.to_d
+      pmt = Flt::DecNum(pmt.to_s)
+      pv = Flt::DecNum(pv.to_s)
 
-      (-1 * pmt / pv)
+      (pmt * -1 / pv)
     end
 
     # Computing Sampling error
     #
     # @param sm sample mean
     # @param mu population mean
-    # @export
-    # @examples
-    # Finrb::Utils.sampling_error(sm=0.45, mu=0.5)
+    # @example
+    #   Finrb::Utils.sampling_error(sm=0.45, mu=0.5)
     def self.sampling_error(sm:, mu:)
-      sm = sm.to_d
-      mu = mu.to_d
+      sm = Flt::DecNum(sm.to_s)
+      mu = Flt::DecNum(mu.to_s)
 
       (sm - mu)
     end
@@ -1040,13 +973,12 @@ module Finrb
     # @param rp portfolio return
     # @param rl threshold level return
     # @param sd standard deviation of portfolio retwns
-    # @export
-    # @examples
-    # Finrb::Utils.sf_ratio(rp=0.09,rl=0.03,sd=0.12)
+    # @example
+    #   Finrb::Utils.sf_ratio(rp=0.09,rl=0.03,sd=0.12)
     def self.sf_ratio(rp:, rl:, sd:)
-      rp = rp.to_d
-      rl = rl.to_d
-      sd = sd.to_d
+      rp = Flt::DecNum(rp.to_s)
+      rl = Flt::DecNum(rl.to_s)
+      sd = Flt::DecNum(sd.to_s)
 
       ((rp - rl) / sd)
     end
@@ -1056,13 +988,12 @@ module Finrb
     # @param rp portfolio return
     # @param rf risk-free return
     # @param sd standard deviation of portfolio retwns
-    # @export
-    # @examples
-    # Finrb::Utils.sharpe_ratio(rp=0.038,rf=0.015,sd=0.07)
+    # @example
+    #   Finrb::Utils.sharpe_ratio(rp=0.038,rf=0.015,sd=0.07)
     def self.sharpe_ratio(rp:, rf:, sd:)
-      rp = rp.to_d
-      rf = rf.to_d
-      sd = sd.to_d
+      rp = Flt::DecNum(rp.to_s)
+      rf = Flt::DecNum(rf.to_s)
+      sd = Flt::DecNum(sd.to_s)
 
       ((rp - rf) / sd)
     end
@@ -1072,13 +1003,12 @@ module Finrb
     # @param cost cost of long-lived assets
     # @param rv   residual value of the long-lived assets at the end of its useful life
     # @param t    length of the useful life
-    # @export
-    # @examples
-    # slde(cost=1200,rv=200,t=5)
+    # @example
+    #   Finrb::Utils.slde(cost=1200,rv=200,t=5)
     def self.slde(cost:, rv:, t:)
-      cost = cost.to_d
-      rv = rv.to_d
-      t = t.to_d
+      cost = Flt::DecNum(cost.to_s)
+      rv = Flt::DecNum(rv.to_s)
+      t = Flt::DecNum(t.to_s)
 
       ((cost - rv) / t)
     end
@@ -1087,12 +1017,11 @@ module Finrb
     #
     # @param td total debt
     # @param te total equity
-    # @export
-    # @examples
-    # Finrb::Utils.total_d2e(td=6000,te=20000)
+    # @example
+    #   Finrb::Utils.total_d2e(td=6000,te=20000)
     def self.total_d2e(td:, te:)
-      td = td.to_d
-      te = te.to_d
+      td = Flt::DecNum(td.to_s)
+      te = Flt::DecNum(te.to_s)
 
       (td / te)
     end
@@ -1102,13 +1031,12 @@ module Finrb
     # @param ev ordered ending value list
     # @param bv ordered beginning value list
     # @param cfr ordered cash flow received list
-    # @export
-    # @examples
-    # twrr(ev=[120,260],bv=[100,240],cfr=[2,4])
+    # @example
+    #   Finrb::Utils.twrr(ev=[120,260],bv=[100,240],cfr=[2,4])
     def self.twrr(ev:, bv:, cfr:)
-      ev = Array.wrap(ev).map(&:to_d)
-      bv = Array.wrap(bv).map(&:to_d)
-      cfr = Array.wrap(cfr).map(&:to_d)
+      ev = Array.wrap(ev).map { |value| Flt::DecNum(value.to_s) }
+      bv = Array.wrap(bv).map { |value| Flt::DecNum(value.to_s) }
+      cfr = Array.wrap(cfr).map { |value| Flt::DecNum(value.to_s) }
 
       r = ev.size
       s = bv.size
@@ -1118,9 +1046,9 @@ module Finrb
         raise(FinrbError, 'Different number of values!')
       else
         (0...r).each do |i|
-          wr *= (hpr(ev[i], bv[i], cfr[i]) + 1)
+          wr *= (Finrb::Utils.hpr(ev: ev[i], bv: bv[i], cfr: cfr[i]) + 1)
         end
-        ((wr**(1 / r)) - 1)
+        ((wr**(1.to_f / r)) - 1)
       end
     end
 
@@ -1128,14 +1056,14 @@ module Finrb
     #
     # @param ns n x 1 vector vector of number of shares
     # @param nm n x 1 vector vector of number of months relate to ns
-    # @export
-    # @examples
-    # s=[10000,2000];m=[12,6];was(ns=s,nm=m)
+    # @example
+    #   s=[10000,2000];m=[12,6];Finrb::Utils.was(ns=s,nm=m)
     #
-    # s=[11000,4400,-3000];m=[12,9,4];was(ns=s,nm=m)
+    # @example
+    #   s=[11000,4400,-3000];m=[12,9,4];Finrb::Utils.was(ns=s,nm=m)
     def self.was(ns:, nm:)
-      ns = Array.wrap(ns).map(&:to_d)
-      nm = Array.wrap(nm).map(&:to_d)
+      ns = Array.wrap(ns).map { |value| Flt::DecNum(value.to_s) }
+      nm = Array.wrap(nm).map { |value| Flt::DecNum(value.to_s) }
 
       m = ns.size
       n = nm.size
@@ -1155,17 +1083,15 @@ module Finrb
     #
     # @param r returns of the individual assets in the portfolio
     # @param w corresponding weights associated with each of the individual assets
-    # @export
-    # @examples
-    # wpr(r=[0.12, 0.07, 0.03],w=[0.5,0.4,0.1])
+    # @example
+    #   Finrb::Utils.wpr(r=[0.12, 0.07, 0.03],w=[0.5,0.4,0.1])
     def self.wpr(r:, w:)
-      r = Array.wrap(r).map(&:to_d)
-      w = Array.wrap(w).map(&:to_d)
+      r = Array.wrap(r).map { |value| Flt::DecNum(value.to_s) }
+      w = Array.wrap(w).map { |value| Flt::DecNum(value.to_s) }
+
+      # TODO: need to change
+      puts('sum of weights is NOT equal to 1!') if w.sum != 1
 
-      if w.sum != 1
-        puts('sum of weights is NOT equal to 1!') # TODO: need to change
-      else
-      end
       r.zip(w).sum { |arr| arr.reduce(:*) }
     end
   end