finrb 0.1.12 → 1.0.0

data/lib/finrb/transaction.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'decimal'
+require_relative 'validation'
 
 module Finrb
   # the Transaction class provides a general interface for working with individual cash flows.
@@ -12,10 +12,10 @@ module Finrb
     # @return [Integer] the period number of the transaction
     # @note this attribute is mainly used in the case of mortgage amortization with no dates
     # @api public
-    attr_accessor :period
+    attr_reader :period
     # @return [Date] the date of the transaction
     # @api public
-    attr_accessor :date
+    attr_reader :date
 
     # create a new Transaction
     # @return [Transaction]
@@ -28,8 +28,11 @@ module Finrb
     #   t = Transaction.new(400, :period => 3)
     # @api public
     def initialize(amount, opts = {})
-      @amount = amount
-      @original = amount
+      raise(ArgumentError, 'options must be a Hash.') unless opts.is_a?(Hash)
+      raise(ArgumentError, 'options may only contain date and period.') unless (opts.keys - %i[date period]).empty?
+
+      self.amount = amount
+      @original = @amount
 
       # Set optional attributes..
       opts.each do |key, value|
@@ -46,7 +49,20 @@ module Finrb
     #   t.amount #=> 750
     # @api public
     def amount=(value)
-      @amount = Flt::DecNum.new(value.to_s) || 0
+      @amount = Validation.decimal(value, name: 'amount')
+    end
+
+    def date=(value)
+      raise(ArgumentError, 'date must respond to to_date.') unless value.nil? || value.respond_to?(:to_date)
+
+      @date = value
+    end
+
+    def period=(value)
+      valid = value.nil? || (value.is_a?(Integer) && !value.negative?)
+      raise(ArgumentError, 'period must be a non-negative integer.') unless valid
+
+      @period = value
     end
 
     # @return [Flt::DecNum] the difference between the original transaction
@@ -85,7 +101,7 @@ module Finrb
     #   pmt.amount #=> -600
     # @api public
     def modify
-      @amount = yield(self)
+      self.amount = yield(self)
     end
 
     # (see #amount)

data/lib/finrb/tvm.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+require_relative 'decimal'
+require_relative 'errors'
+require_relative 'numerical/brent'
+
+module Finrb
+  # Time-value-of-money calculations for periodic rates and cashflows.
+  module TVM
+    module_function
+
+    def discount_rate(n:, pv:, fv:, pmt:, type: 0, lower: 0.0001, upper: 100)
+      n, pv, fv, pmt, type, lower, upper = decimals(n, pv, fv, pmt, type, lower, upper)
+      function = ->(rate) { fv_simple(r: rate, n:, pv:) + fv_annuity(r: rate, n:, pmt:, type:) - fv }
+
+      Numerical::Brent.new(tolerance: Finrb.config.eps).solve(function, lower:, upper:)
+    end
+
+    def fv(r:, n:, pv: 0, pmt: 0, type: 0)
+      r, n, pv, pmt, type = decimals(r, n, pv, pmt, type)
+      validate_payment_type!(type)
+
+      fv_simple(r:, n:, pv:) + fv_annuity(r:, n:, pmt:, type:)
+    end
+
+    def fv_annuity(r:, n:, pmt:, type: 0)
+      r, n, pmt, type = decimals(r, n, pmt, type)
+      validate_payment_type!(type)
+
+      (pmt / r * (((r + 1)**n) - 1)) * ((r + 1)**type) * -1
+    end
+
+    def fv_simple(r:, n:, pv:)
+      r, n, pv = decimals(r, n, pv)
+      (pv * ((r + 1)**n)) * -1
+    end
+
+    def fv_uneven(r:, cf:)
+      r = Flt::DecNum(r.to_s)
+      cashflows = array(cf).map { |value| Flt::DecNum(value.to_s) }
+
+      cashflows.each_with_index.sum do |cashflow, index|
+        fv_simple(r:, n: cashflows.size - index - 1, pv: cashflow)
+      end
+    end
+
+    def n_period(r:, pv:, fv:, pmt:, type: 0)
+      r, pv, fv, pmt, type = decimals(r, pv, fv, pmt, type)
+      validate_payment_type!(type)
+
+      numerator = ((fv * r) - (pmt * ((r + 1)**type))) * -1
+      denominator = (pv * r) + (pmt * ((r + 1)**type))
+      (numerator / denominator).log / (r + 1).log
+    end
+
+    def npv(r:, cf:)
+      cashflows = array(cf).map { |value| Flt::DecNum(value.to_s) }
+      (pv_uneven(r:, cf: cashflows.drop(1)) * -1) + cashflows.first
+    end
+
+    def pmt(r:, n:, pv:, fv:, type: 0)
+      r, n, pv, fv, type = decimals(r, n, pv, fv, type)
+      validate_payment_type!(type)
+
+      (pv + (fv / ((r + 1)**n))) * r / (1 - (Flt::DecNum(1) / ((r + 1)**n))) * -1 * ((r + 1)**(type * -1))
+    end
+
+    def pv(r:, n:, fv: 0, pmt: 0, type: 0)
+      r, n, fv, pmt, type = decimals(r, n, fv, pmt, type)
+      validate_payment_type!(type)
+
+      pv_simple(r:, n:, fv:) + pv_annuity(r:, n:, pmt:, type:)
+    end
+
+    def pv_annuity(r:, n:, pmt:, type: 0)
+      r, n, pmt, type = decimals(r, n, pmt, type)
+      validate_payment_type!(type)
+
+      (pmt / r * (1 - (Flt::DecNum(1) / ((r + 1)**n)))) * ((r + 1)**type) * -1
+    end
+
+    def pv_perpetuity(r:, pmt:, g: 0, type: 0)
+      r, pmt, g, type = decimals(r, pmt, g, type)
+      validate_payment_type!(type)
+      raise(Error, 'Error: g is not smaller than r!') if g >= r
+
+      (pmt / (r - g)) * ((r + 1)**type) * -1
+    end
+
+    def pv_simple(r:, n:, fv:)
+      r, n, fv = decimals(r, n, fv)
+      (fv / ((r + 1)**n)) * -1
+    end
+
+    def pv_uneven(r:, cf:)
+      r = Flt::DecNum(r.to_s)
+      array(cf).each_with_index.sum do |cashflow, index|
+        pv_simple(r:, n: index + 1, fv: cashflow)
+      end
+    end
+
+    def r_perpetuity(pmt:, pv:)
+      pmt, pv = decimals(pmt, pv)
+      pmt * -1 / pv
+    end
+
+    def array(value)
+      return [] if value.nil?
+      return value.to_ary || [value] if value.respond_to?(:to_ary)
+
+      [value]
+    end
+    private_class_method :array
+
+    def decimals(*values)
+      values.map { |value| Flt::DecNum(value.to_s) }
+    end
+    private_class_method :decimals
+
+    def validate_payment_type!(type)
+      raise(Error, 'Error: type should be 0 or 1!') unless [Flt::DecNum(0), Flt::DecNum(1)].include?(type)
+    end
+    private_class_method :validate_payment_type!
+  end
+end

data/lib/finrb/validation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'decimal'
+
+module Finrb
+  # Shared validation and decimal coercion for public financial inputs.
+  module Validation
+    module_function
+
+    def decimal(value, name:)
+      raise(ArgumentError, "#{name} must be numeric.") unless value.is_a?(Numeric)
+
+      decimal = value.is_a?(Flt::DecNum) ? value : Flt::DecNum.new(value.to_s)
+      raise(ArgumentError, "#{name} must be finite.") unless decimal.finite?
+
+      decimal
+    rescue Flt::Num::Exception, FloatDomainError, Math::DomainError => e
+      raise(ArgumentError, "#{name} must be a finite numeric value.", e.backtrace)
+    end
+
+    def positive_integer(value, name:)
+      raise(ArgumentError, "#{name} must be a positive integer.") unless value.is_a?(Integer) && value.positive?
+
+      value
+    end
+  end
+end

data/lib/finrb/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Finrb
+  VERSION = '1.0.0'
+  public_constant :VERSION
+end

data/lib/finrb/yields.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative 'decimal'
+require_relative 'errors'
+
+module Finrb
+  # Money-market yield and interest-rate conversion calculations.
+  module Yields
+    # Computing bank discount yield (BDY) for a T-bill
+    #
+    # @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
+    # @example
+    #   Finrb::Yields.bdy(d=1500,f=100000,t=120)
+    def self.bdy(d:, f:, t:)
+      d = Flt::DecNum(d.to_s)
+      f = Flt::DecNum(f.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (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
+    # @example
+    #   Finrb::Yields.bdy2mmy(bdy=0.045,t=120)
+    def self.bdy2mmy(bdy:, t:)
+      bdy = Flt::DecNum(bdy.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (bdy * 360 / (360 - (t * bdy)))
+    end
+
+    # Convert stated annual rate to the effective annual rate
+    #
+    # @param r stated annual rate
+    # @param m number of compounding periods per year
+    # @example
+    #   Finrb::Yields.ear(r=0.12,m=12)
+    #
+    # @example
+    #   Finrb::Yields.ear(0.04,365)
+    def self.ear(r:, m:)
+      r = Flt::DecNum(r.to_s)
+      m = Flt::DecNum(m.to_s)
+
+      ((((r / m) + 1)**m) - 1)
+    end
+
+    # Convert stated annual rate to the effective annual rate with continuous compounding
+    #
+    # @param r stated annual rate
+    # @example
+    #   Finrb::Yields.ear_continuous(r=0.1)
+    #
+    # @example
+    #   Finrb::Yields.ear_continuous(0.03)
+    def self.ear_continuous(r:)
+      r = Flt::DecNum(r.to_s)
+
+      (r.exp - 1)
+    end
+
+    # bond-equivalent yield (BEY), 2 x the semiannual discount rate
+    #
+    # @param ear effective annual rate
+    # @example
+    #   Finrb::Yields.ear2bey(ear=0.08)
+    def self.ear2bey(ear:)
+      ear = Flt::DecNum(ear.to_s)
+
+      (((ear + 1).sqrt - 1) * 2)
+    end
+
+    # Computing HPR, the holding period return
+    #
+    # @param ear effective annual rate
+    # @param t number of days remaining until maturity
+    # @example
+    #   Finrb::Yields.ear2hpr(ear=0.05039,t=150)
+    def self.ear2hpr(ear:, t:)
+      ear = Flt::DecNum(ear.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (((ear + 1)**(t / 365)) - 1)
+    end
+
+    # Equivalent/proportional Interest Rates
+    # @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')
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per year
+    #   Finrb::Yields.eir(r=0.05,n=1,p=12)
+    #
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per half year
+    #   Finrb::Yields.eir(r=0.05,n=2,p=12)
+    #
+    # @example
+    #   # monthly interest rat equivalent to 5% compounded per quarter
+    #   Finrb::Yields.eir(r=0.05,n=4,p=12)
+    #
+    # @example
+    #   # annual interest rate equivalent to 5% compounded per month
+    #   Finrb::Yields.eir(r=0.05,n=12,p=1)
+    #   # this is equivalent to
+    #   Finrb::Yields.ear(r=0.05,m=12)
+    #
+    # @example
+    #   # quarter interest rate equivalent to 5% compounded per year
+    #   Finrb::Yields.eir(r=0.05,n=1,p=4)
+    #
+    # @example
+    #   # quarter interest rate equivalent to 5% compounded per month
+    #   Finrb::Yields.eir(r=0.05,n=12,p=4)
+    #
+    # @example
+    #   # monthly proportional interest rate which is equivalent to a simple annual interest
+    #   Finrb::Yields.eir(r=0.05,p=12,type='p')
+    def self.eir(r:, n: 1, p: 12, type: 'e')
+      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 = (((r / n) + 1)**(n / p)) - 1
+      when 'p'
+        eir = r / p
+      else
+        raise(Error, "type must be 'e' or 'p'")
+      end
+      eir
+    end
+
+    # bond-equivalent yield (BEY), 2 x the semiannual discount rate
+    #
+    # @param hpr holding period return
+    # @param t number of month remaining until maturity
+    # @example
+    #   Finrb::Yields.hpr2bey(hpr=0.02,t=3)
+    def self.hpr2bey(hpr:, t:)
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      ((((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
+    # @example
+    #   Finrb::Yields.hpr2ear(hpr=0.015228,t=120)
+    def self.hpr2ear(hpr:, t:)
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (((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
+    # @example
+    #   Finrb::Yields.hpr2mmy(hpr=0.01523,t=120)
+    def self.hpr2mmy(hpr:, t:)
+      hpr = Flt::DecNum(hpr.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (hpr * 360 / t)
+    end
+
+    # Computing HPR, the holding period return
+    #
+    # @param mmy money market yield
+    # @param t number of days remaining until maturity
+    # @example
+    #   Finrb::Yields.mmy2hpr(mmy=0.04898,t=150)
+    def self.mmy2hpr(mmy:, t:)
+      mmy = Flt::DecNum(mmy.to_s)
+      t = Flt::DecNum(t.to_s)
+
+      (mmy * t / 360)
+    end
+
+    # Convert a given norminal rate to a continuous compounded rate
+    #
+    # @param r norminal rate
+    # @param m number of times compounded each year
+    # @example
+    #   Finrb::Yields.r_continuous(r=0.03,m=4)
+    def self.r_continuous(r:, m:)
+      r = Flt::DecNum(r.to_s)
+      m = Flt::DecNum(m.to_s)
+
+      (m * ((r / m) + 1).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
+    # @example
+    #   Finrb::Yields.r_norminal(0.03,1)
+    #
+    # @example
+    #   Finrb::Yields.r_norminal(rc=0.03,m=4)
+    def self.r_norminal(rc:, m:)
+      rc = Flt::DecNum(rc.to_s)
+      m = Flt::DecNum(m.to_s)
+
+      (m * ((rc / m).exp - 1))
+    end
+  end
+end

data/lib/finrb.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
-require 'active_support'
+require 'finrb/accounting'
 require 'finrb/cashflows'
 require 'finrb/config'
 require 'finrb/decimal'
-require 'finrb/utils'
+require 'finrb/errors'
+require 'finrb/precision'
+require 'finrb/ratios'
+require 'finrb/returns'
+require 'finrb/tvm'
+require 'finrb/version'
+require 'finrb/yields'
 
-class FinrbError < StandardError; end
+FinrbError = Finrb::Error
 
 # The *Finrb* module adheres to the following conventions for
 # financial calculations:
@@ -19,5 +25,4 @@ module Finrb
   autoload :Amortization, 'finrb/amortization'
   autoload :Rate,         'finrb/rates'
   autoload :Transaction,  'finrb/transaction'
-  autoload :Utils,        'finrb/utils'
 end

data/sig/finrb.rbs

@@ -0,0 +1,204 @@
+module Flt
+  class DecNum < Numeric
+  end
+end
+
+module Finrb
+  VERSION: String
+
+  type number = Numeric
+  type decimal = Flt::DecNum
+  type numbers = Array[number] | Enumerable[number]
+
+  interface _Configuration
+    def eps: () -> decimal
+    def guess: () -> decimal
+    def business_days: () -> bool
+    def periodic_compound: () -> bool
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  interface _ConfigurationBuilder
+    def eps: () -> untyped
+    def eps=: (untyped) -> untyped
+    def guess: () -> untyped
+    def guess=: (untyped) -> untyped
+    def business_days: () -> untyped
+    def business_days=: (untyped) -> untyped
+    def periodic_compound: () -> untyped
+    def periodic_compound=: (untyped) -> untyped
+  end
+
+  def self.config: () -> _Configuration
+  def self.configure: () { (_ConfigurationBuilder) -> void } -> _Configuration
+  def self.with_config: [A] (**untyped) { () -> A } -> A
+
+  class Error < StandardError
+  end
+
+  class ConvergenceError < Error
+  end
+
+  class DomainError < Error
+  end
+
+  class InvalidCashflowError < Error
+  end
+
+  module Precision
+    def self.money: (number) -> decimal
+    def self.rate: (number) -> decimal
+    def self.round: (number, places: Integer) -> decimal
+  end
+
+  class Rate
+    include Comparable
+
+    TYPES: Hash[Symbol, String]
+
+    def self.to_effective: (number, number) -> decimal
+    def self.to_nominal: (number, number) -> decimal
+
+    def initialize: (number, Symbol, ?Hash[Symbol, untyped]) -> void
+    def duration: () -> Integer?
+    def effective: () -> decimal
+    def nominal: () -> decimal
+    def <=>: (Rate) -> Integer?
+    def apr: () -> decimal
+    def apy: () -> decimal
+    def duration=: (Integer) -> Integer
+    def inspect: () -> String
+    def monthly: () -> decimal
+  end
+
+  class Transaction
+    def initialize: (number, ?Hash[Symbol, untyped]) -> void
+    def amount: () -> decimal
+    def amount=: (number) -> number
+    def period: () -> Integer?
+    def period=: (Integer?) -> Integer?
+    def date: () -> untyped
+    def date=: (untyped) -> untyped
+    def difference: () -> decimal
+    def interest?: () -> bool
+    def inspect: () -> String
+    def modify: () { (Transaction) -> number } -> number
+    def payment: () -> decimal
+    def payment?: () -> bool
+  end
+
+  class Interest < Transaction
+  end
+
+  class Payment < Transaction
+  end
+
+  class Amortization
+    def self.payment: (number, number, Integer) -> decimal
+
+    def initialize: (number, *Rate) ?{ (Transaction) -> number } -> void
+    def ==: (untyped) -> bool
+    def balance: () -> decimal
+    def payment: () -> decimal?
+    def principal: () -> decimal
+    def rates: () -> Array[Rate]
+    def additional_payments: () -> Array[decimal]
+    def duration: () -> Integer
+    def inspect: () -> String
+    def interest: () -> Array[decimal]
+    def payments: () -> Array[decimal]
+  end
+
+  module Cashflow
+    def self.irr: (Enumerable[number], ?number) -> decimal
+    def self.npv: (Enumerable[number], number) -> decimal
+    def self.xirr: (Enumerable[Transaction], ?number) -> Rate
+    def self.xnpv: (Enumerable[Transaction], number) -> decimal
+
+    def irr: (?number) -> decimal
+    def npv: (number) -> decimal
+    def xirr: (?number) -> Rate
+    def xnpv: (number) -> decimal
+  end
+
+  module TVM
+    def self.discount_rate: (n: number, pv: number, fv: number, pmt: number, ?type: Integer, ?lower: number, ?upper: number) -> decimal
+    def self.fv: (r: number, n: number, ?pv: number, ?pmt: number, ?type: Integer) -> decimal
+    def self.fv_annuity: (r: number, n: number, pmt: number, ?type: Integer) -> decimal
+    def self.fv_simple: (r: number, n: number, pv: number) -> decimal
+    def self.fv_uneven: (r: number, cf: number | numbers) -> decimal
+    def self.n_period: (r: number, pv: number, fv: number, pmt: number, ?type: Integer) -> decimal
+    def self.npv: (r: number, cf: number | numbers) -> decimal
+    def self.pmt: (r: number, n: number, pv: number, fv: number, ?type: Integer) -> decimal
+    def self.pv: (r: number, n: number, ?fv: number, ?pmt: number, ?type: Integer) -> decimal
+    def self.pv_annuity: (r: number, n: number, pmt: number, ?type: Integer) -> decimal
+    def self.pv_perpetuity: (r: number, pmt: number, ?g: number, ?type: Integer) -> decimal
+    def self.pv_simple: (r: number, n: number, fv: number) -> decimal
+    def self.pv_uneven: (r: number, cf: number | numbers) -> decimal
+    def self.r_perpetuity: (pmt: number, pv: number) -> decimal
+  end
+
+  module Accounting
+    type inventory_result = { cost_of_goods: decimal, ending_inventory: decimal }
+
+    def self.cogs: (uinv: number, pinv: number, units: number | numbers, price: number | numbers, sinv: number, ?method: String) -> inventory_result
+    def self.ddb: (cost: number, rv: number, t: Integer) -> { t: Array[Integer], ddb: Array[decimal] }
+    def self.slde: (cost: number, rv: number, t: number) -> decimal
+  end
+
+  module Ratios
+    def self.cash_ratio: (cash: number, ms: number, cl: number) -> decimal
+    def self.current_ratio: (ca: number, cl: number) -> decimal
+    def self.debt_ratio: (td: number, ta: number) -> decimal
+    def self.diluted_eps: (ni: number, pd: number, w: number, ?cpd: number, ?cdi: number, ?tax: number, ?cps: number, ?cds: number, ?iss: number) -> decimal
+    def self.eps: (ni: number, pd: number, w: number) -> decimal
+    def self.financial_leverage: (te: number, ta: number) -> decimal
+    def self.gpm: (gp: number, rv: number) -> decimal
+    def self.iss: (amp: number, ep: number, n: number) -> decimal
+    def self.lt_d2e: (ltd: number, te: number) -> decimal
+    def self.npm: (ni: number, rv: number) -> decimal
+    def self.quick_ratio: (cash: number, ms: number, rc: number, cl: number) -> decimal
+    def self.total_d2e: (td: number, te: number) -> decimal
+    def self.was: (ns: number | numbers | nil, nm: number | numbers | nil) -> (decimal | Integer)
+  end
+
+  module Returns
+    def self.coefficient_variation: (sd: number, avg: number) -> decimal
+    def self.geometric_mean: (r: number | numbers) -> decimal
+    def self.harmonic_mean: (p: number | numbers) -> decimal
+    def self.hpr: (ev: number, bv: number, ?cfr: number) -> decimal
+    def self.sampling_error: (sm: number, mu: number) -> decimal
+    def self.sf_ratio: (rp: number, rl: number, sd: number) -> decimal
+    def self.sharpe_ratio: (rp: number, rf: number, sd: number) -> decimal
+    def self.twrr: (ev: number | numbers, bv: number | numbers, cfr: number | numbers) -> decimal
+    def self.wpr: (r: number | numbers, w: number | numbers) -> decimal
+  end
+
+  module Yields
+    def self.bdy: (d: number, f: number, t: number) -> decimal
+    def self.bdy2mmy: (bdy: number, t: number) -> decimal
+    def self.ear: (r: number, m: number) -> decimal
+    def self.ear_continuous: (r: number) -> decimal
+    def self.ear2bey: (ear: number) -> decimal
+    def self.ear2hpr: (ear: number, t: number) -> decimal
+    def self.eir: (r: number, ?n: number, ?p: number, ?type: String) -> decimal
+    def self.hpr2bey: (hpr: number, t: number) -> decimal
+    def self.hpr2ear: (hpr: number, t: number) -> decimal
+    def self.hpr2mmy: (hpr: number, t: number) -> decimal
+    def self.mmy2hpr: (mmy: number, t: number) -> decimal
+    def self.r_continuous: (r: number, m: number) -> decimal
+    def self.r_norminal: (rc: number, m: number) -> decimal
+  end
+
+  module Numerical
+    class Brent
+      def initialize: (tolerance: number, ?relative_tolerance: number, ?max_iterations: Integer) -> void
+      def solve: (^(decimal) -> number, lower: number, upper: number) -> decimal
+    end
+
+    class RateSearch
+      def initialize: (?step: number, ?max_steps: Integer) -> void
+      def bracket: (^(decimal) -> number, guess: number) -> [decimal, decimal]
+    end
+  end
+end