finrb 1.1.0 → 1.3.0

data/lib/finrb/calendars/israel_tase.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'hebrew_calendar'
+
+module Finrb
+  module Calendars
+    # Tel Aviv Stock Exchange full-day trading calendar.
+    class IsraelTase < Base
+      # Contract window: QuantLib 1.43 supplies TASE holiday data through 2050.
+      # Earlier dates and later projections are not validated by this profile.
+      SUPPORTED_START_DATE = Date.new(2000, 1, 1, Date::GREGORIAN)
+      SUPPORTED_END_DATE = Date.new(2050, 12, 31, Date::GREGORIAN)
+      SUPPORTED_DATE_RANGE = (SUPPORTED_START_DATE..SUPPORTED_END_DATE)
+      public_constant :SUPPORTED_START_DATE, :SUPPORTED_END_DATE, :SUPPORTED_DATE_RANGE
+
+      TRADING_WEEK_CHANGE = Date.new(2026, 1, 5, Date::GREGORIAN)
+      WEEKEND_BEFORE_CHANGE = [5, 6].freeze
+      WEEKEND_AFTER_CHANGE = [0, 6].freeze
+      public_constant :TRADING_WEEK_CHANGE
+      private_constant :WEEKEND_BEFORE_CHANGE, :WEEKEND_AFTER_CHANGE
+
+      def name
+        'Israel TASE'
+      end
+
+      protected
+
+      def weekend?(date)
+        weekend_days = date < TRADING_WEEK_CHANGE ? WEEKEND_BEFORE_CHANGE : WEEKEND_AFTER_CHANGE
+        weekend_days.include?(date.wday)
+      end
+
+      def holidays_for(date)
+        names = {}
+        ((date.year + 3759)..(date.year + 3761)).each do |hebrew_year|
+          hebrew_holidays(hebrew_year).each do |holiday_date, name|
+            (names[holiday_date] ||= []).concat(name)
+          end
+        end
+        add(names, Date.new(2026, 1, 4, Date::GREGORIAN), 'TASE trading-week transition')
+        names.fetch(date, [])
+      end
+
+      private
+
+      def hebrew_holidays(year)
+        holidays = {}
+        add(holidays, HebrewCalendar.date(year - 1, 6, 29), 'Rosh Hashanah Eve')
+        add(holidays, HebrewCalendar.date(year, 7, 1), 'Rosh Hashanah I')
+        add(holidays, HebrewCalendar.date(year, 7, 2), 'Rosh Hashanah II')
+        add(holidays, HebrewCalendar.date(year, 7, 9), 'Yom Kippur Eve')
+        add(holidays, HebrewCalendar.date(year, 7, 10), 'Yom Kippur')
+        add(holidays, HebrewCalendar.date(year, 7, 14), 'Sukkot Eve')
+        add(holidays, HebrewCalendar.date(year, 7, 15), 'Sukkot')
+        add(holidays, HebrewCalendar.date(year, 7, 21), 'Shemini Atzeret Eve')
+        add(holidays, HebrewCalendar.date(year, 7, 22), 'Shemini Atzeret / Simchat Torah')
+
+        adar = HebrewCalendar.leap_year?(year) ? 13 : 12
+        add(holidays, HebrewCalendar.date(year, adar, 14), 'Purim')
+
+        add(holidays, HebrewCalendar.date(year, 1, 14), 'Passover Eve I')
+        add(holidays, HebrewCalendar.date(year, 1, 15), 'Passover I')
+        add(holidays, HebrewCalendar.date(year, 1, 20), 'Passover Eve VII')
+        add(holidays, HebrewCalendar.date(year, 1, 21), 'Passover VII')
+        add(holidays, israel_independence_day(year) - 1, 'Memorial Day')
+        add(holidays, israel_independence_day(year), 'Independence Day')
+        add(holidays, HebrewCalendar.date(year, 3, 5), 'Shavuot Eve')
+        add(holidays, HebrewCalendar.date(year, 3, 6), 'Shavuot')
+        add(holidays, tisha_bav(year), 'Tisha B’Av')
+        holidays
+      end
+
+      def israel_independence_day(year)
+        date = HebrewCalendar.date(year, 2, 5)
+        day =
+          case date.wday
+          when 6 then 3
+          when 5 then 4
+          when 1 then 6
+          else 5
+          end
+        HebrewCalendar.date(year, 2, day)
+      end
+
+      def tisha_bav(year)
+        date = HebrewCalendar.date(year, 5, 9)
+        date.saturday? ? date + 1 : date
+      end
+
+      def add(holidays, date, name)
+        (holidays[date] ||= []) << name
+      end
+    end
+  end
+end

data/lib/finrb/calendars/us_federal_reserve.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Finrb
+  module Calendars
+    # Federal Reserve Bank payment-business calendar (not NYSE or federal staff leave).
+    class USFederalReserve < Base
+      # Contract window: QuantLib 1.43 was exhaustively checked over these years;
+      # pre-1950 history is intentionally outside this profile and later dates
+      # are rejected rather than silently extrapolated.
+      SUPPORTED_START_DATE = Date.new(1950, 1, 1, Date::GREGORIAN)
+      SUPPORTED_END_DATE = Date.new(2065, 12, 31, Date::GREGORIAN)
+      SUPPORTED_DATE_RANGE = (SUPPORTED_START_DATE..SUPPORTED_END_DATE)
+      public_constant :SUPPORTED_START_DATE, :SUPPORTED_END_DATE, :SUPPORTED_DATE_RANGE
+
+      WEEKEND_DAYS = [0, 6].freeze
+      private_constant :WEEKEND_DAYS
+
+      def name
+        'US Federal Reserve'
+      end
+
+      protected
+
+      def weekend?(date)
+        WEEKEND_DAYS.include?(date.wday)
+      end
+
+      def holidays_for(date)
+        year = date.year
+        holidays = {}
+        add_fixed_holiday(holidays, year, 1, 1, "New Year's Day")
+        add_weekday_holiday(holidays, nth_weekday(year, 1, 1, 3), 'Birthday of Martin Luther King, Jr.') if year >= 1983
+        if year < 1971
+          add_pre_1971_fixed_holiday(holidays, Date.new(year, 2, 22, Date::GREGORIAN), "Washington's Birthday")
+          add_pre_1971_fixed_holiday(holidays, Date.new(year, 5, 30, Date::GREGORIAN), 'Memorial Day')
+        else
+          add_weekday_holiday(holidays, nth_weekday(year, 2, 1, 3), "Washington's Birthday")
+          add_weekday_holiday(holidays, last_weekday(year, 5, 1), 'Memorial Day')
+        end
+        add_fixed_holiday(holidays, year, 6, 19, 'Juneteenth National Independence Day') if year >= 2021
+        add_fixed_holiday(holidays, year, 7, 4, 'Independence Day')
+        add_weekday_holiday(holidays, nth_weekday(year, 9, 1, 1), 'Labor Day')
+        add_weekday_holiday(holidays, nth_weekday(year, 10, 1, 2), 'Columbus Day') if year >= 1971
+        add_fixed_holiday(holidays, year, 11, 11, 'Veterans Day') unless year.between?(1971, 1977)
+        add_weekday_holiday(holidays, nth_weekday(year, 10, 1, 4), 'Veterans Day') if year.between?(1971, 1977)
+        add_weekday_holiday(holidays, nth_weekday(year, 11, 4, 4), 'Thanksgiving Day')
+        add_fixed_holiday(holidays, year, 12, 25, 'Christmas Day')
+        holidays.fetch(date, [])
+      end
+
+      private
+
+      def add_fixed_holiday(holidays, year, month, day, name)
+        date = Date.new(year, month, day, Date::GREGORIAN)
+        add_weekday_holiday(holidays, date, name)
+        add_weekday_holiday(holidays, date + 1, name) if date.sunday?
+      end
+
+      def add_pre_1971_fixed_holiday(holidays, date, name)
+        add_weekday_holiday(holidays, date, name)
+        add_weekday_holiday(holidays, date - 1, name) if date.saturday?
+        add_weekday_holiday(holidays, date + 1, name) if date.sunday?
+      end
+
+      def add_weekday_holiday(holidays, date, name)
+        (holidays[date] ||= []) << name
+      end
+
+      def nth_weekday(year, month, weekday, occurrence)
+        first = Date.new(year, month, 1, Date::GREGORIAN)
+        first + ((weekday - first.wday) % 7) + ((occurrence - 1) * 7)
+      end
+
+      def last_weekday(year, month, weekday)
+        last = Date.new(year, month, -1, Date::GREGORIAN)
+        last - ((last.wday - weekday) % 7)
+      end
+    end
+  end
+end

data/lib/finrb/calendars.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'finrb/calendars/base'
+require 'finrb/calendars/hebrew_calendar'
+require 'finrb/calendars/israel_tase'
+require 'finrb/calendars/us_federal_reserve'

data/lib/finrb/cashflows.rb

@@ -77,8 +77,7 @@ module Finrb
       validate_numeric_cashflows!
       cashflows = map { |entry| Validation.decimal(entry, name: 'cashflow amount') }
 
-      rate = Validation.decimal(rate, name: 'rate')
-      raise(DomainError, 'Rate must be greater than -1.') if rate <= -1
+      rate = Validation.decimal_greater_than(rate, minimum: -1, name: 'rate', error: DomainError)
 
       total = Flt::DecNum.new(0.to_s)
       cashflows.each_with_index do |cashflow, index|
@@ -98,9 +97,8 @@ module Finrb
       cashflows = map { |entry| Validation.decimal(entry, name: 'cashflow amount') }
       raise(InvalidCashflowError, 'Cashflow needs at least one positive and one negative value.') if cashflows.none?(&:positive?) || cashflows.none?(&:negative?)
 
-      finance_rate = Validation.decimal(finance_rate, name: 'finance_rate')
-      reinvestment_rate = Validation.decimal(reinvestment_rate, name: 'reinvestment_rate')
-      raise(DomainError, 'Finance and reinvestment rates must be greater than -1.') if finance_rate <= -1 || reinvestment_rate <= -1
+      finance_rate = Validation.decimal_greater_than(finance_rate, minimum: -1, name: 'finance rate', error: DomainError)
+      reinvestment_rate = Validation.decimal_greater_than(reinvestment_rate, minimum: -1, name: 'reinvestment rate', error: DomainError)
 
       last_period = cashflows.size - 1
       future_positive =
@@ -156,8 +154,7 @@ module Finrb
     #   Finrb::Cashflow.xnpv(@transactions, 0.6).round(2) #=> -937.41
     def xnpv(rate)
       validate_dated_cashflows!
-      rate = Validation.decimal(rate, name: 'rate')
-      raise(DomainError, 'Rate must be greater than -1.') if rate <= -1
+      rate = Validation.decimal_greater_than(rate, minimum: -1, name: 'rate', error: DomainError)
 
       sum do |t|
         t.amount / ((rate + 1)**(date_diff(start, t.date) / days_in_period))

data/lib/finrb/config.rb

@@ -41,16 +41,16 @@ module Finrb
   end
 
   def self.build_configuration(values)
-    eps = configuration_decimal(values.fetch(:eps), name: 'eps')
-    raise(ArgumentError, 'eps must be positive.') unless eps.positive?
+    eps = configuration_decimal(values.fetch(:eps), name: 'solver tolerance')
+    raise(ArgumentError, 'solver tolerance must be positive.') unless eps.positive?
 
-    guess = configuration_decimal(values.fetch(:guess), name: 'guess')
-    raise(ArgumentError, 'guess must be greater than -1.') if guess <= -1
+    guess = configuration_decimal(values.fetch(:guess), name: 'rate guess')
+    raise(ArgumentError, 'rate guess must be greater than -1.') if guess <= -1
 
     business_days = values.fetch(:business_days)
     periodic_compound = values.fetch(:periodic_compound)
     booleans = [business_days, periodic_compound].all? { |value| value.equal?(true) || value.equal?(false) }
-    raise(ArgumentError, 'business_days and periodic_compound must be boolean.') unless booleans
+    raise(ArgumentError, 'business days and periodic compounding settings must be boolean.') unless booleans
 
     Configuration.new(eps:, guess:, business_days:, periodic_compound:)
   end

data/lib/finrb/day_count.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'decimal'
+require 'date'
+
+module Finrb
+  # Year-fraction calculations used to express elapsed time under a named
+  # financial day-count convention.
+  module DayCount
+    CONVENTIONS = %i[actual_365_fixed actual_360 actual_actual_icma].freeze
+    DEFAULT = :actual_365_fixed
+    public_constant :CONVENTIONS, :DEFAULT
+
+    module_function
+
+    # Calculate a signed year fraction. Actual/Actual ICMA requires the regular
+    # coupon reference period and coupon frequency containing the date range.
+    def year_fraction(start_date, end_date, convention: DEFAULT, reference_period_start: nil, reference_period_end: nil, frequency: nil)
+      raise(ArgumentError, "day-count convention must be one of #{CONVENTIONS.join(', ')}.") unless CONVENTIONS.include?(convention)
+
+      start_date = normalize_date(start_date, 'start_date')
+      end_date = normalize_date(end_date, 'end_date')
+
+      if convention == :actual_actual_icma
+        icma_year_fraction(start_date, end_date, reference_period_start, reference_period_end, frequency)
+      else
+        reject_reference_period_arguments!(reference_period_start, reference_period_end, frequency)
+        denominator = convention == :actual_360 ? 360 : 365
+
+        Flt::DecNum((end_date - start_date).to_i.to_s) / Flt::DecNum(denominator.to_s)
+      end
+    end
+
+    def icma_year_fraction(start_date, end_date, reference_period_start, reference_period_end, frequency)
+      raise(ArgumentError, 'Actual/Actual ICMA requires reference_period_start, reference_period_end, and frequency.') unless reference_period_start && reference_period_end && frequency
+
+      reference_period_start = normalize_date(reference_period_start, 'reference_period_start')
+      reference_period_end = normalize_date(reference_period_end, 'reference_period_end')
+      raise(ArgumentError, 'reference_period_end must be after reference_period_start.') if reference_period_end <= reference_period_start
+      raise(ArgumentError, 'frequency must be a positive integer.') unless frequency.is_a?(Integer) && frequency.positive?
+
+      elapsed_days = Flt::DecNum((end_date - start_date).to_i.to_s)
+      reference_days = Flt::DecNum((reference_period_end - reference_period_start).to_i.to_s)
+      elapsed_days / (reference_days * frequency)
+    end
+    private_class_method :icma_year_fraction
+
+    def reject_reference_period_arguments!(reference_period_start, reference_period_end, frequency)
+      return if reference_period_start.nil? && reference_period_end.nil? && frequency.nil?
+
+      raise(ArgumentError, 'reference-period arguments are only valid for Actual/Actual ICMA.')
+    end
+    private_class_method :reject_reference_period_arguments!
+
+    def normalize_date(date, name)
+      raise(ArgumentError, "#{name} must be a Date.") unless date.instance_of?(Date)
+
+      Date.new(date.year, date.month, date.day, Date::GREGORIAN)
+    end
+    private_class_method :normalize_date
+  end
+end

data/lib/finrb/fixed_rate_bond.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative 'calendars'
+require_relative 'config'
+require_relative 'day_count'
+require_relative 'errors'
+require_relative 'numerical/brent'
+require_relative 'numerical/rate_search'
+require_relative 'schedule'
+require_relative 'transaction'
+require_relative 'validation'
+
+module Finrb
+  # Fixed-coupon bullet bond valuation under explicit Actual/Actual ICMA rules.
+  class FixedRateBond
+    PRICE_TYPES = %i[clean dirty].freeze
+    public_constant :PRICE_TYPES
+
+    CouponPeriod = Data.define(:accrual_start_date, :accrual_end_date, :payment_date, :amount)
+    private_constant :CouponPeriod
+
+    attr_reader :face_value, :coupon_rate, :issue_date, :maturity_date, :frequency, :schedule, :calendar, :business_day_convention
+
+    def initialize(face_value:, coupon_rate:, issue_date:, maturity_date:, frequency: :semiannual, calendar: nil, business_day_convention: nil)
+      @face_value = Validation.positive_decimal(face_value, name: 'face value')
+      @coupon_rate = Validation.non_negative_decimal(coupon_rate, name: 'annual coupon rate')
+      @schedule = Schedule.new(start_date: issue_date, maturity_date:, frequency:, calendar:, business_day_convention:)
+
+      @issue_date = schedule.start_date
+      @maturity_date = schedule.maturity_date
+      @frequency = frequency
+      @coupon_frequency = 12 / Schedule::FREQUENCY_MONTHS.fetch(frequency)
+      @calendar = calendar
+      @business_day_convention = business_day_convention
+      @coupon_periods = build_coupon_periods.freeze
+      freeze
+    end
+
+    def day_count
+      :actual_actual_icma
+    end
+
+    # Return future coupon and redemption cashflows as dated positive transactions.
+    def cashflows(settlement_date:)
+      settlement_date = validate_settlement_date!(settlement_date)
+      cashflows =
+        @coupon_periods.filter_map.with_index do |period, index|
+          next if period.payment_date <= settlement_date
+
+          amount = period.amount
+          amount += face_value if index == @coupon_periods.length - 1
+          Transaction.new(amount, date: period.payment_date)
+        end
+      cashflows.freeze
+    end
+
+    def accrued_interest(settlement_date:)
+      settlement_date = validate_settlement_date!(settlement_date)
+      period = @coupon_periods.find { |coupon_period| coupon_period.payment_date > settlement_date }
+      return Flt::DecNum(0) if period.nil?
+
+      accrual_end = [settlement_date, period.accrual_end_date].min
+      return Flt::DecNum(0) if accrual_end <= period.accrual_start_date
+
+      fraction = icma_fraction(period.accrual_start_date, accrual_end, period.accrual_start_date, period.accrual_end_date)
+      face_value * coupon_rate * fraction
+    end
+
+    def dirty_price(settlement_date:, yield_rate:)
+      settlement_date = validate_settlement_date!(settlement_date)
+      yield_rate = Validation.decimal_greater_than(yield_rate, minimum: -1, name: 'bond yield', error: DomainError)
+      periodic_yield = yield_rate / @coupon_frequency
+      discount_base = periodic_yield + 1
+
+      @coupon_periods.each_with_index.sum(Flt::DecNum(0)) do |period, index|
+        next Flt::DecNum(0) if period.payment_date <= settlement_date
+
+        amount = period.amount
+        amount += face_value if index == @coupon_periods.length - 1
+        elapsed_coupon_periods = schedule_year_fraction(settlement_date, period.payment_date) * @coupon_frequency
+        amount / (discount_base**elapsed_coupon_periods)
+      end
+    end
+
+    def clean_price(settlement_date:, yield_rate:)
+      dirty_price(settlement_date:, yield_rate:) - accrued_interest(settlement_date:)
+    end
+
+    def yield_to_maturity(settlement_date:, price:, price_type: :clean, guess: Finrb.config.guess)
+      settlement_date = validate_settlement_date!(settlement_date)
+      raise(ArgumentError, "price_type must be one of #{PRICE_TYPES.join(', ')}.") unless PRICE_TYPES.include?(price_type)
+
+      quoted_price = Validation.positive_decimal(price, name: "#{price_type} bond price", error: DomainError)
+      dirty_price_target = price_type == :clean ? quoted_price + accrued_interest(settlement_date:) : quoted_price
+      rate_function = ->(rate) { dirty_price(settlement_date:, yield_rate: rate) - dirty_price_target }
+      bounds = Numerical::RateSearch.new.bracket(rate_function, guess:)
+      return bounds.first if bounds.first == bounds.last
+
+      Numerical::Brent.new(tolerance: Finrb.config.eps).solve(rate_function, lower: bounds.first, upper: bounds.last)
+    end
+
+    private
+
+    def build_coupon_periods
+      previous_unadjusted_date = issue_date
+      schedule.periods.map do |period|
+        accrual_start_date = previous_unadjusted_date
+        accrual_end_date = period.unadjusted_payment_date
+        fraction = icma_fraction(accrual_start_date, accrual_end_date, accrual_start_date, accrual_end_date)
+        coupon_amount = face_value * coupon_rate * fraction
+        previous_unadjusted_date = accrual_end_date
+        CouponPeriod.new(accrual_start_date:, accrual_end_date:, payment_date: period.payment_date, amount: coupon_amount)
+      end
+    end
+
+    def icma_fraction(start_date, end_date, reference_period_start, reference_period_end)
+      DayCount.year_fraction(start_date, end_date, convention: :actual_actual_icma, reference_period_start:, reference_period_end:, frequency: @coupon_frequency)
+    end
+
+    def schedule_year_fraction(start_date, end_date)
+      @coupon_periods.sum(Flt::DecNum(0)) do |period|
+        overlap_start = [start_date, period.accrual_start_date].max
+        overlap_end = [end_date, period.accrual_end_date].min
+        next Flt::DecNum(0) if overlap_end <= overlap_start
+
+        icma_fraction(overlap_start, overlap_end, period.accrual_start_date, period.accrual_end_date)
+      end
+    end
+
+    def validate_settlement_date!(date)
+      raise(ArgumentError, 'settlement_date must be a Date.') unless date.instance_of?(Date)
+
+      date = Date.new(date.year, date.month, date.day, Date::GREGORIAN)
+      raise(ArgumentError, 'settlement_date must be on or after issue_date.') if date < issue_date
+      raise(ArgumentError, 'settlement_date must be before maturity_date.') if date >= maturity_date
+
+      date
+    end
+  end
+end

data/lib/finrb/rates.rb

@@ -17,10 +17,7 @@ module Finrb
       infinite = value.infinite? if value.respond_to?(:infinite?)
       return Flt::DecNum.infinity if [true, 1].include?(infinite)
 
-      periods = Validation.decimal(value, name: 'compounding periods')
-      raise(ArgumentError, 'compounding periods must be positive.') unless periods.positive?
-
-      periods
+      Validation.positive_decimal(value, name: 'compounding periods', message: 'compounding periods must be positive.')
     end
     private_class_method :compounding_periods
 
@@ -49,8 +46,7 @@ module Finrb
     #   Rate.to_nominal(0.06, 365) #=> Flt::DecNum('0.05827')
     # @see https://www.miniwebtool.com/nominal-interest-rate-calculator/
     def self.to_nominal(rate, periods)
-      rate = Validation.decimal(rate, name: 'rate')
-      raise(ArgumentError, 'effective rate must be greater than -1.') if rate <= -1
+      rate = Validation.decimal_greater_than(rate, minimum: -1, name: 'effective rate')
 
       periods = compounding_periods(periods)
 
@@ -141,7 +137,7 @@ module Finrb
     end
 
     def duration=(value)
-      @duration = Validation.positive_integer(value, name: 'duration')
+      @duration = Validation.positive_integer(value, name: 'duration in months')
     end
 
     # set the effective interest rate

data/lib/finrb/ratios.rb

@@ -2,6 +2,7 @@
 
 require_relative 'decimal'
 require_relative 'errors'
+require_relative 'validation'
 
 module Finrb
   # Financial-statement, leverage, and per-share ratios.
@@ -25,9 +26,9 @@ module Finrb
     # @example
     #   Finrb::Ratios.cash_ratio(cash=3000,ms=2000,cl=2000)
     def self.cash_ratio(cash:, ms:, cl:)
-      cash = Flt::DecNum(cash.to_s)
-      ms = Flt::DecNum(ms.to_s)
-      cl = Flt::DecNum(cl.to_s)
+      cash = Validation.decimal(cash, name: 'cash')
+      ms = Validation.decimal(ms, name: 'marketable securities')
+      cl = Validation.non_zero_decimal(cl, name: 'current liabilities', error: DomainError)
 
       ((cash + ms) / cl)
     end
@@ -39,8 +40,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.current_ratio(ca=8000,cl=2000)
     def self.current_ratio(ca:, cl:)
-      ca = Flt::DecNum(ca.to_s)
-      cl = Flt::DecNum(cl.to_s)
+      ca = Validation.decimal(ca, name: 'current assets')
+      cl = Validation.non_zero_decimal(cl, name: 'current liabilities', error: DomainError)
 
       (ca / cl)
     end
@@ -52,8 +53,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.debt_ratio(td=6000,ta=20000)
     def self.debt_ratio(td:, ta:)
-      td = Flt::DecNum(td.to_s)
-      ta = Flt::DecNum(ta.to_s)
+      td = Validation.decimal(td, name: 'total debt')
+      ta = Validation.non_zero_decimal(ta, name: 'total assets', error: DomainError)
 
       (td / ta)
     end
@@ -81,15 +82,15 @@ module Finrb
     # @example
     #   Finrb::Ratios.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 = 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)
+      ni = Validation.decimal(ni, name: 'net income')
+      pd = Validation.decimal(pd, name: 'preferred dividends')
+      w = Validation.positive_decimal(w, name: 'weighted average common shares', error: DomainError)
+      cpd = Validation.non_negative_decimal(cpd, name: 'convertible preferred dividends')
+      cdi = Validation.non_negative_decimal(cdi, name: 'convertible debt interest')
+      tax = Validation.decimal_between(tax, minimum: 0, maximum: 1, name: 'tax rate')
+      cps = Validation.non_negative_decimal(cps, name: 'convertible preferred shares')
+      cds = Validation.non_negative_decimal(cds, name: 'convertible debt shares')
+      iss = Validation.non_negative_decimal(iss, name: 'incremental option shares')
 
       basic = (ni - pd) / w
       diluted = (ni - pd + cpd + (cdi * (1 - tax))) / (w + cps + cds + iss)
@@ -105,9 +106,9 @@ module Finrb
     # @example
     #   Finrb::Ratios.eps(ni=10000,pd=1000,w=11000)
     def self.eps(ni:, pd:, w:)
-      ni = Flt::DecNum(ni.to_s)
-      pd = Flt::DecNum(pd.to_s)
-      w = Flt::DecNum(w.to_s)
+      ni = Validation.decimal(ni, name: 'net income')
+      pd = Validation.decimal(pd, name: 'preferred dividends')
+      w = Validation.positive_decimal(w, name: 'weighted average common shares', error: DomainError)
 
       ((ni - pd) / w)
     end
@@ -119,8 +120,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.financial_leverage(te=16000,ta=20000)
     def self.financial_leverage(te:, ta:)
-      te = Flt::DecNum(te.to_s)
-      ta = Flt::DecNum(ta.to_s)
+      te = Validation.non_zero_decimal(te, name: 'total equity', error: DomainError)
+      ta = Validation.decimal(ta, name: 'total assets')
 
       (ta / te)
     end
@@ -132,8 +133,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.gpm(gp=1000,rv=20000)
     def self.gpm(gp:, rv:)
-      gp = Flt::DecNum(gp.to_s)
-      rv = Flt::DecNum(rv.to_s)
+      gp = Validation.decimal(gp, name: 'gross profit')
+      rv = Validation.non_zero_decimal(rv, name: 'revenue', error: DomainError)
 
       (gp / rv)
     end
@@ -146,14 +147,14 @@ module Finrb
     # @example
     #   Finrb::Ratios.iss(amp=20,ep=15,n=10000)
     def self.iss(amp:, ep:, n:)
-      amp = Flt::DecNum(amp.to_s)
-      ep = Flt::DecNum(ep.to_s)
-      n = Flt::DecNum(n.to_s)
+      amp = Validation.positive_decimal(amp, name: 'average market price', error: DomainError)
+      ep = Validation.non_negative_decimal(ep, name: 'exercise price')
+      n = Validation.non_negative_decimal(n, name: 'option shares')
 
       if amp > ep
         ((amp - ep) * n / amp)
       else
-        raise(Error, 'amp must larger than ep')
+        raise(DomainError, 'Average market price must be greater than exercise price.')
       end
     end
 
@@ -164,8 +165,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.lt_d2e(ltd=8000,te=20000)
     def self.lt_d2e(ltd:, te:)
-      ltd = Flt::DecNum(ltd.to_s)
-      te = Flt::DecNum(te.to_s)
+      ltd = Validation.decimal(ltd, name: 'long-term debt')
+      te = Validation.non_zero_decimal(te, name: 'total equity', error: DomainError)
 
       (ltd / te)
     end
@@ -177,8 +178,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.npm(ni=8000,rv=20000)
     def self.npm(ni:, rv:)
-      ni = Flt::DecNum(ni.to_s)
-      rv = Flt::DecNum(rv.to_s)
+      ni = Validation.decimal(ni, name: 'net income')
+      rv = Validation.non_zero_decimal(rv, name: 'revenue', error: DomainError)
 
       (ni / rv)
     end
@@ -192,10 +193,10 @@ module Finrb
     # @example
     #   Finrb::Ratios.quick_ratio(cash=3000,ms=2000,rc=1000,cl=2000)
     def self.quick_ratio(cash:, ms:, rc:, cl:)
-      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 = Validation.decimal(cash, name: 'cash')
+      ms = Validation.decimal(ms, name: 'marketable securities')
+      rc = Validation.decimal(rc, name: 'receivables')
+      cl = Validation.non_zero_decimal(cl, name: 'current liabilities', error: DomainError)
 
       ((cash + ms + rc) / cl)
     end
@@ -207,8 +208,8 @@ module Finrb
     # @example
     #   Finrb::Ratios.total_d2e(td=6000,te=20000)
     def self.total_d2e(td:, te:)
-      td = Flt::DecNum(td.to_s)
-      te = Flt::DecNum(te.to_s)
+      td = Validation.decimal(td, name: 'total debt')
+      te = Validation.non_zero_decimal(te, name: 'total equity', error: DomainError)
 
       (td / te)
     end
@@ -223,8 +224,8 @@ module Finrb
     # @example
     #   s=[11000,4400,-3000];m=[12,9,4];Finrb::Ratios.was(ns=s,nm=m)
     def self.was(ns:, nm:)
-      ns = wrap_array(ns).map { |value| Flt::DecNum(value.to_s) }
-      nm = wrap_array(nm).map { |value| Flt::DecNum(value.to_s) }
+      ns = wrap_array(ns).map { |value| Validation.decimal(value, name: 'share change') }
+      nm = wrap_array(nm).map { |value| Validation.decimal_between(value, minimum: 0, maximum: 12, name: 'months outstanding') }
 
       m = ns.size
       n = nm.size
@@ -234,7 +235,7 @@ module Finrb
           sum += (ns[i] * nm[i])
         end
       else
-        raise(Error, 'length of ns and nm must be equal')
+        raise(ArgumentError, 'Share changes and months outstanding must have equal lengths.')
       end
       sum /= 12
       sum