finmodeling 0.1 → 0.2

data/lib/finmodeling/annual_report_filing.rb

@@ -4,12 +4,14 @@ module FinModeling
 
     CONSTRUCTOR_PATH = File.join(FinModeling::BASE_PATH, "constructors/")
     SCHEMA_VERSION_ITEM = "@schema_version"
-    CURRENT_SCHEMA_VERSION = 1.1
+    CURRENT_SCHEMA_VERSION = 1.3
     # History:
     # 1.0: initial version
     # 1.1: added CFS to quarterly filings
     #      added disclosures
     #      renamed fake(.*)report to cached(.*)report
+    # 1.2: added shareholders' equity statement
+    # 1.3: added comprehensive income statement
 
     def self.download(url)
       uid = url.split("/")[-2..-1].join('-').gsub(/\.[A-zA-z]*$/, '')
@@ -37,11 +39,13 @@ module FinModeling
     def balance_sheet
       if @balance_sheet.nil?
         calculations=@taxonomy.callb.calculation
-        bal_sheet = calculations.find{ |x| (x.clean_downcased_title =~ /statement.*financial.*position/) or
-                                           (x.clean_downcased_title =~ /statement.*financial.*condition/) or
-                                           (x.clean_downcased_title =~ /balance.*sheet/) }
+        bal_sheet = calculations.find{ |x| ((x.clean_downcased_title =~ /statement.*financial.*position/) ||
+                                            (x.clean_downcased_title =~ /statement.*financial.*condition/) ||
+                                            (x.clean_downcased_title =~ /balance.*sheet/)) &&
+                                           !(x.clean_downcased_title =~ /^balances included/) &&
+                                           !(x.clean_downcased_title =~ /net of tax/) }
         if bal_sheet.nil?
-          raise RuntimeError.new("Couldn't find balance sheet in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
+          raise InvalidFilingError.new("Couldn't find balance sheet in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
         end
     
         @balance_sheet = BalanceSheetCalculation.new(bal_sheet)
@@ -52,12 +56,15 @@ module FinModeling
     def income_statement
       if @income_stmt.nil?
         calculations=@taxonomy.callb.calculation
-        inc_stmt = calculations.find{ |x| (x.clean_downcased_title =~ /statement.*operations/) or
-                                          (x.clean_downcased_title =~ /statement[s]*.*of.*earnings/) or
-                                          (x.clean_downcased_title =~ /statement[s]*.*of.*income/) or
-                                          (x.clean_downcased_title =~ /statement[s]*.*of.*net.*income/) }
+        inc_stmt = calculations.find{ |x| ((x.clean_downcased_title =~ /statement(|s).*operations/) ||
+                                           (x.clean_downcased_title =~ /statement(|s).*of.*earnings/) ||
+                                           (x.clean_downcased_title =~ /statement(|s).*of.*(|net.*)income/) ||
+                                           (x.clean_downcased_title =~ /(|net.*)income.*statement(|s)/)) &&
+                                          !(x.clean_downcased_title =~ /comprehensive/) &&
+                                          !(x.clean_downcased_title =~ /schedule/) &&
+                                          !(x.clean_downcased_title =~ /disclosure/) }
         if inc_stmt.nil?
-          raise RuntimeError.new("Couldn't find income statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
+          raise InvalidFilingError.new("Couldn't find income statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
         end
     
         @income_stmt = IncomeStatementCalculation.new(inc_stmt)
@@ -65,13 +72,48 @@ module FinModeling
       return @income_stmt
     end
 
+    def has_an_income_statement?
+      begin
+        return income_statement ? true : false
+      rescue
+        return false
+      end
+    end
+
+    def comprehensive_income_statement
+      if @comprehensive_income_stmt.nil?
+        calculations=@taxonomy.callb.calculation
+        inc_stmt = calculations.find{ |x| ((x.clean_downcased_title =~ /statement.*operations/) ||
+                                           (x.clean_downcased_title =~ /statement.*of.*earnings/) ||
+                                           (x.clean_downcased_title =~ /statement.*of.*income/) ||
+                                           (x.clean_downcased_title =~ /income.*statement/)) &&
+                                           (x.clean_downcased_title =~ /comprehensive/) &&
+                                          !(x.clean_downcased_title =~ /and other comprehensive/) &&
+                                          !(x.clean_downcased_title =~ /statement of stockholders equity/) }
+        if inc_stmt.nil?
+          raise InvalidFilingError.new("Couldn't find comprehensive income statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
+        end
+    
+        @comprehensive_income_stmt = ComprehensiveIncomeStatementCalculation.new(inc_stmt)
+      end
+      return @comprehensive_income_stmt
+    end
+
+    def has_a_comprehensive_income_statement?
+      begin
+        return comprehensive_income_statement ? true : false
+      rescue
+        return false
+      end
+    end
+
     def cash_flow_statement
       if @cash_flow_stmt.nil?
         calculations=@taxonomy.callb.calculation
-        cash_flow_stmt = calculations.find{ |x| (x.clean_downcased_title =~ /statement.*cash.*flows/) or
-                                                (x.clean_downcased_title =~ /^cash flows$/) }
+        cash_flow_stmt = calculations.find{ |x| (x.clean_downcased_title =~ /statement.*cash.*flow(|s)/) ||
+                                                (x.clean_downcased_title =~ /^cash flow(|s)$/) }
         if cash_flow_stmt.nil?
-          raise RuntimeError.new("Couldn't find cash flow statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
+          raise InvalidFilingError.new("Couldn't find cash flow statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
         end
     
         @cash_flow_stmt = CashFlowStatementCalculation.new(cash_flow_stmt)
@@ -79,14 +121,51 @@ module FinModeling
       return @cash_flow_stmt
     end
 
+    def has_a_shareholder_equity_statement?
+      #puts "calculations: " + @taxonomy.callb.calculation.map{ |x| x.clean_downcased_title }.join(',')
+      begin
+        return !shareholder_equity_statement.nil?
+      rescue
+        return false
+      end
+    end
+
+    def shareholder_equity_statement
+      if @shareholder_equity_stmt.nil?
+        calculations=@taxonomy.callb.calculation
+        shareholder_equity_stmt = calculations.find{ |x| (x.clean_downcased_title =~ /statement(|s).*of.*(share|stock)holders(|').*equity(|.*and.*comprehensive|.*and.*other.*comprehensive|.*and.*comprehensive)(|.*income|.*loss|.*income.*loss|.*loss.*income)$/) ||
+                                                         (x.clean_downcased_title =~ /statements.*of.*changes.*in.*shareholders.*equity/) }
+        if shareholder_equity_stmt.nil?
+          raise InvalidFilingError.new("Couldn't find shareholders' equity statement in: " + calculations.map{ |x| "\"#{x.clean_downcased_title}\"" }.join("; "))
+        end
+    
+        @shareholder_equity_stmt = ShareholderEquityStatementCalculation.new(shareholder_equity_stmt)
+      end
+      return @shareholder_equity_stmt
+    end
+
     def is_valid?
-      return (income_statement.is_valid? and balance_sheet.is_valid? and cash_flow_statement.is_valid?)
+      puts "balance sheet is not valid" if !balance_sheet.is_valid?
+      puts "income statment is not valid" if has_an_income_statement? && !income_statement.is_valid?
+      puts "comprehensive income statment is not valid" if has_a_comprehensive_income_statement? && !comprehensive_income_statement.is_valid?
+      #puts "cash flow statement is not valid" if !cash_flow_statement.is_valid?
+
+      return false if !balance_sheet.is_valid?
+      return false if has_an_income_statement? && !income_statement.is_valid?
+      return false if has_a_comprehensive_income_statement? && !comprehensive_income_statement.is_valid?
+      #return false if !cash_flow_statement.is_valid? # FIXME: why can't we enable this?
+      return true
     end
 
     def write_constructor(file, item_name)
-      balance_sheet.write_constructor(      file, bs_name  = item_name + "_bs")
-      income_statement.write_constructor(   file, is_name  = item_name + "_is")
-      cash_flow_statement.write_constructor(file, cfs_name = item_name + "_cfs")
+      balance_sheet                 .write_constructor(file, bs_name  = item_name + "_bs" )
+      income_statement              .write_constructor(file, is_name  = item_name + "_is" ) if has_an_income_statement?
+      comprehensive_income_statement.write_constructor(file, cis_name = item_name + "_cis") if has_a_comprehensive_income_statement?
+      cash_flow_statement           .write_constructor(file, cfs_name = item_name + "_cfs")
+      shareholder_equity_statement  .write_constructor(file, ses_name = item_name + "_ses") if has_a_shareholder_equity_statement?
+      is_name  = "nil" if !has_an_income_statement?
+      cis_name = "nil" if !has_a_comprehensive_income_statement?
+      ses_name = "nil" if !has_a_shareholder_equity_statement?
 
       names_of_discs = []
       disclosures.each_with_index do |disclosure, idx|
@@ -98,7 +177,7 @@ module FinModeling
 
       file.puts "#{SCHEMA_VERSION_ITEM} = #{CURRENT_SCHEMA_VERSION}" 
 
-      file.puts "#{item_name} = FinModeling::CachedAnnualFiling.new(#{bs_name}, #{is_name}, #{cfs_name}, #{names_of_discs_str})"
+      file.puts "#{item_name} = FinModeling::CachedAnnualFiling.new(#{bs_name}, #{is_name}, #{cis_name}, #{cfs_name}, #{ses_name}, #{names_of_discs_str})"
     end
   end
 end

data/lib/finmodeling/assets_calculation.rb

@@ -17,9 +17,6 @@ module FinModeling
       thesummary = lookup_cached_summary(summary_cache_key)
       return thesummary if !thesummary.nil?
 
-      mapping = Xbrlware::ValueMapping.new
-      mapping.policy[:credit] = :flip
-
       thesummary = super(:period => args[:period], :mapping => mapping)
       if !lookup_cached_classifications(BASE_FILENAME, thesummary.rows)
         lookahead = [4, thesummary.rows.length-1].min
@@ -32,5 +29,17 @@ module FinModeling
       return thesummary
     end
 
+    def mapping
+      m = Xbrlware::ValueMapping.new
+      m.policy[:credit] = :flip
+      m
+    end
+
+    def has_cash_item 
+      @has_cash_item = leaf_items.any? do |leaf|
+        leaf.name.downcase.matches_any_regex?([/cash/])
+      end
+    end
+
   end
 end

data/lib/finmodeling/balance_sheet_analyses.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module FinModeling
 
   class BalanceSheetAnalyses < CalculationSummary
@@ -11,19 +13,32 @@ module FinModeling
       @totals_row_enabled = false
     end
 
-    def print_extras # FIXME: rename
+    def print_regressions # FIXME: rename
       lr = noa_growth_row.valid_vals.linear_regression
-      puts "\t\tNOA growth: "+
+      puts "\t\tNOA growth:        "+
+           "a:#{lr.a.to_s.cap_decimals(4)}, "+
+           "b:#{lr.b.to_s.cap_decimals(4)}, "+
+           "r²:#{lr.r2.to_s.cap_decimals(4)}, "+
+           "σ²:#{noa_growth_row.valid_vals.variance.to_s.cap_decimals(4)}, " +
+           ( (lr.r2 > 0.6) ? "strong fit" : ( (lr.r2 < 0.2) ? "weak fit [**]" : "avg fit") )
+
+      lr = composition_ratio_row.valid_vals.linear_regression
+      puts "\t\tComposition ratio: "+
            "a:#{lr.a.to_s.cap_decimals(4)}, "+
            "b:#{lr.b.to_s.cap_decimals(4)}, "+
-           "r:#{lr.r.to_s.cap_decimals(4)}, "+
-           "var:#{noa_growth_row.valid_vals.variance.to_s.cap_decimals(4)}"
+           "r²:#{lr.r2.to_s.cap_decimals(4)}, "+
+           "σ²:#{composition_ratio_row.valid_vals.variance.to_s.cap_decimals(4)}, " +
+           ( (lr.r2 > 0.6) ? "strong fit" : ( (lr.r2 < 0.2) ? "weak fit [**]" : "avg fit") )
     end
 
     def noa_growth_row
       find_row_by_key('NOA Growth')
     end
 
+    def composition_ratio_row
+      find_row_by_key('Composition Ratio')
+    end
+
     def find_row_by_key(key) # FIXME: move this to CalculationSummary
       self.rows.find{ |x| x.key == key }
     end

data/lib/finmodeling/balance_sheet_calculation.rb

@@ -1,60 +1,58 @@
 module FinModeling
   class BalanceSheetCalculation < CompanyFilingCalculation
 
+    ASSETS_GOAL        = "assets"
+    ASSETS_LABELS      = [ /(^total *|^consolidated *|^)assets(| BS)$/,
+                           /^assets total$/ ]
+    ASSETS_ANTI_LABELS = [ ]
+    ASSETS_IDS         = [ /^(|Locator_|loc_)(|us-gaap_)Assets[_a-z0-9]+/ ]
     def assets_calculation
-      if @assets.nil?
-        friendly_goal = "assets"
-        label_regexes = [ /(^total *|^consolidated *|^)assets$/,
-                          /^assets total$/ ]
-        id_regexes    = [ /^(|Locator_|loc_)(|us-gaap_)Assets[_a-z0-9]+/ ]
-  
-        calc = find_and_verify_calculation_arc(friendly_goal, label_regexes, id_regexes)
-        @assets = AssetsCalculation.new(calc)
+      begin
+        @assets ||= AssetsCalculation.new(find_calculation_arc(ASSETS_GOAL, ASSETS_LABELS, ASSETS_ANTI_LABELS, ASSETS_IDS))
+      rescue FinModeling::InvalidFilingError => e
+        pre_msg = "calculation tree:\n" + self.calculation.sprint_tree
+        raise e, pre_msg+e.message, e.backtrace
       end
-      return @assets
     end
   
+    LIABS_AND_EQ_GOAL        = "liabilities and equity"
+    LIABS_AND_EQ_LABELS      = [ /(^total *|^)liabilities.*and.*(equity|stockholders investment)/ ]
+    LIABS_AND_EQ_ANTI_LABELS = [ ]
+    LIABS_AND_EQ_IDS         = [ /.*/ ] # FIXME: no checking...
     def liabs_and_equity_calculation
-       if @liabs_and_equity.nil?
-        friendly_goal = "liabilities and equity"
-        label_regexes = [ /(^total *|^)liabilities.*and.*equity/ ]
-        id_regexes    = [ /.*/ ] # no checking...
-  
-        calc = find_and_verify_calculation_arc(friendly_goal, label_regexes, id_regexes)
-        @liabs_and_equity = LiabsAndEquityCalculation.new(calc)
+      begin
+        @liabs_and_eq ||= LiabsAndEquityCalculation.new(find_calculation_arc(LIABS_AND_EQ_GOAL, LIABS_AND_EQ_LABELS, LIABS_AND_EQ_ANTI_LABELS, LIABS_AND_EQ_IDS))
+      rescue FinModeling::InvalidFilingError => e
+        pre_msg = "calculation tree:\n" + self.calculation.sprint_tree
+        raise e, pre_msg+e.message, e.backtrace
       end
-      return @liabs_and_equity
     end
 
     def is_valid?
-      has_cash_item = false
-      assets_calculation.leaf_items.each do |leaf|
-        if !has_cash_item and leaf.name.downcase.matches_regexes?([/cash/])
-          has_cash_item = true
-        end
-      end
+      puts "balance sheet's assets calculation lacks cash item"                   if !assets_calculation.has_cash_item 
+      puts "balance sheet's liabilities and equity calculation lacks equity item" if !liabs_and_equity_calculation.has_equity_item 
+      puts "balance sheet's isn't balanced"                                       if !is_balanced
 
-      has_equity_item = false
-      liabs_and_equity_calculation.leaf_items.each do |leaf|
-        if !has_equity_item and leaf.name.downcase.matches_regexes?([/equity/, /stock/])
-          has_equity_item = true
+      if !assets_calculation.has_cash_item || !liabs_and_equity_calculation.has_equity_item || !is_balanced
+        if assets_calculation
+          puts "assets summary:"
+          assets_calculation.summary(:period => periods.last).print
+        end
+        if liabs_and_equity_calculation
+          puts "liabs & equity summary:"
+          liabs_and_equity_calculation.summary(:period => periods.last).print
         end
+        puts "calculation tree:\n" + self.calculation.sprint_tree(indent_count=0, simplified=true)
       end
 
-      left = assets_calculation.leaf_items_sum(:period => periods.last)
-      right = liabs_and_equity_calculation.leaf_items_sum(:period => periods.last)
-      allowed_error = 1.0
-      is_balanced = (left - right) < allowed_error
-
-      puts "balance sheet's assets calculation lacks cash item" if !has_cash_item 
-      puts "balance sheet's liabilities and equity calculation lacks equity item" if !has_equity_item 
-      puts "balance sheet's isn't balanced (#{left}, #{right})" if !is_balanced
-      return (has_cash_item and has_equity_item and is_balanced)
+      return (assets_calculation.has_cash_item && 
+              liabs_and_equity_calculation.has_equity_item && 
+              is_balanced)
     end
 
     def reformulated(period)
       return ReformulatedBalanceSheet.new(period, 
-                                          assets_calculation.summary(:period=>period), 
+                                          assets_calculation          .summary(:period=>period), 
                                           liabs_and_equity_calculation.summary(:period=>period))
     end
 
@@ -64,5 +62,22 @@ module FinModeling
       file.puts "#{item_name} = FinModeling::BalanceSheetCalculation.new(#{item_calc_name})"
     end
 
+    def is_balanced
+      left  = assets_calculation          .leaf_items_sum(:period => periods.last, :mapping => assets_calculation.mapping)
+      right = liabs_and_equity_calculation.leaf_items_sum(:period => periods.last, :mapping => liabs_and_equity_calculation.mapping)
+
+      is_bal = (left - right) < ((0.5*(left + right))/1000.0)
+      if !is_bal
+        puts "balance sheet last period: #{periods.last.inspect}"
+        puts "balance sheet left  side: #{left}"
+        puts "balance sheet right side: #{right}"
+        puts "left:"
+        assets_calculation.summary(:period => periods.last).print
+        puts "right:"
+        liabs_and_equity_calculation.summary(:period => periods.last).print
+      end
+      is_bal
+    end
+
   end
 end

data/lib/finmodeling/calculation_summary.rb

@@ -10,11 +10,40 @@ module FinModeling
     end
 
     def valid_vals
-      ArrayWithStats.new(@vals.select{ |val| !val.nil? })
+      ArrayWithStats.new(@vals.select{ |val| !val.nil? &&
+                                             !val.is_a?(Complex) &&
+                                             (!val.is_a?(Float) || (!val.nan? && val.finite?))})
+    end
+
+    def num_vals
+      @vals.length
+    end
+
+    def min_abs_val
+      @vals.map{ |x| x.abs }.min
+    end
+
+    def scale_down_by(val)
+      if val == :thousand
+        @vals.map!{ |val| val / 1000.0 }
+        @key += " ($KK)"
+      elsif val == :million
+        @vals.map!{ |val| val / 1000000.0 }
+        @key += " ($MM)"
+      else
+        raise RuntimeError.new("Bogus val: #{val}")
+      end
+    end
+
+    def insert_column_before(col_idx, val)
+      @vals.insert(col_idx, val)
     end
 
     def print(key_width=18, max_decimals=4, val_width=12)
-      justified_key = @key.fixed_width_left_justify(key_width)
+      type_and_key = ""
+      type_and_key += "[#{@type}] " if @type
+      type_and_key += @key
+      key_lines = type_and_key.split_into_lines_shorter_than(key_width).map{ |line| line.fixed_width_left_justify(key_width) }
   
       justified_vals = ""
       @vals.each do |val|
@@ -22,7 +51,10 @@ module FinModeling
         justified_vals += "  " + val_with_commas.cap_decimals(max_decimals).fixed_width_right_justify(val_width) 
       end
    
-      puts "\t" + justified_key + justified_vals
+      puts "\t" + key_lines.shift + justified_vals
+      key_lines.each do |line|
+        puts "\t " + line
+      end
     end
 
     def write_constructor(file, item_name)
@@ -63,10 +95,25 @@ module FinModeling
       @val_width = 12
       @max_decimals = 4
       @totals_row_enabled = true
+      @rows = [ ]
     end
 
     def num_value_columns
-      @rows.map{ |row| row.vals.length }.max
+      @rows.map{ |row| row.num_vals }.max
+    end
+
+    def auto_scale!
+      min_val = @rows.map{ |row| row.min_abs_val }.min
+      if min_val >= 1000 && min_val < 100000
+        @rows.each { |row| row.scale_down_by(:thousand) }
+      elsif min_val >= 1000000
+        @rows.each { |row| row.scale_down_by(:million) }
+      end
+    end
+
+    def insert_column_before(col_idx, val=nil)
+      @header_row.insert_column_before(col_idx, val) if @header_row
+      @rows.each{ |row| row.insert_column_before(col_idx, val) }
     end
 
     def total(col_idx=0)
@@ -120,24 +167,82 @@ module FinModeling
       file.puts "#{item_name}.rows = [#{row_item_names.join(',')}]"
     end
 
-    def +(mccs)
-      raise RuntimeError.new("can't add a CalculationSummary to a #{mccs.class}") if !mccs.is_a?(CalculationSummary)
-      raise RuntimeError.new("can't add CalculationSummaries with different numbers of rows") if @rows.length != mccs.rows.length
-
+    def +(other)
+      raise RuntimeError.new("can't add a CalculationSummary to a #{other.class}") if !other.is_a?(CalculationSummary)
       multics = CalculationSummary.new
       multics.title = @title
+      multics.rows = []
 
       if @header_row
         multics.header_row = CalculationHeader.new(
                                :key  => @header_row.key.dup, 
-                               :vals => @header_row.vals.dup + mccs.header_row.vals.dup)
+                               :vals => @header_row.vals.dup + other.header_row.vals.dup)
       end
 
-      multics.rows = []
-      0.upto(@rows.length-1).each do |idx|
-        multics.rows << CalculationRow.new(
-                          :key  => @rows[idx].key.dup, 
-                          :vals => @rows[idx].vals.dup + mccs.rows[idx].vals.dup)
+      myrows  = @rows.dup
+      itsrows = other.rows.dup
+      while myrows.any? || itsrows.any?
+        new_row = CalculationRow.new( :key  => "", :vals => [] )
+
+        if    (myrows.any? && itsrows.empty?)
+          new_row.key = myrows.first.key.dup
+          new_row.vals += myrows.first.vals.dup
+          new_row.vals += [""]*other.num_value_column
+
+          myrows.shift
+
+        elsif (myrows.empty? && itsrows.any?)
+          new_row.key = itsrows.first.key.dup
+          new_row.vals += [""]*num_value_columns
+          new_row.vals += itsrows.first.vals.dup
+
+          itsrows.shift
+
+        elsif (myrows.first.key == itsrows.first.key)
+          new_row.key = myrows.first.key.dup
+          new_row.vals += myrows.first.vals.dup 
+          new_row.vals += itsrows.first.vals.dup
+
+          myrows.shift
+          itsrows.shift
+
+        elsif (myrows.first.key < itsrows.first.key)
+          if myrow=myrows.find{|row| row.key == itsrows.first.key }
+            new_row.key = myrows.first.key.dup
+            new_row.vals += myrows.first.vals.dup
+            new_row.vals += itsrows.first.vals.dup
+
+            myrows.delete(myrow)
+            itsrows.shift
+
+          else
+            new_row.key = itsrows.first.key.dup
+            new_row.vals += [""]*num_value_columns
+            new_row.vals += itsrows.first.vals.dup
+
+            itsrows.shift
+          end
+
+        elsif (myrows.first.key > itsrows.first.key)
+          if itsrow=itsrows.find{|row| row.key == myrows.first.key }
+            new_row.key = myrows.first.key.dup
+            new_row.vals += myrows.first.vals.dup 
+            new_row.vals += itsrows.first.vals.dup
+
+            myrows.shift
+            itsrows.delete(itsrow)
+
+          else
+            new_row.key = myrows.first.key.dup
+            new_row.vals += myrows.first.vals.dup
+            new_row.vals += [""]*other.num_value_columns
+
+            myrows.shift
+          end
+
+        end
+
+        multics.rows << new_row
       end
 
       return multics

data/lib/finmodeling/can_choose_successive_periods.rb

@@ -0,0 +1,15 @@
+module CanChooseSuccessivePeriods
+  protected
+
+  def choose_successive_periods(cur_calc, prev_calc)
+    if         cur_calc.periods.halfyearly    .any? && prev_calc.periods.quarterly     .any?
+      return [ cur_calc.periods.halfyearly    .last ,  prev_calc.periods.quarterly     .last ]
+    elsif      cur_calc.periods.threequarterly.any? && prev_calc.periods.halfyearly    .any?
+      return [ cur_calc.periods.threequarterly.last ,  prev_calc.periods.halfyearly    .last ]
+    elsif      cur_calc.periods.yearly        .any? && prev_calc.periods.threequarterly.any?
+      return [ cur_calc.periods.yearly        .last ,  prev_calc.periods.threequarterly.last ]
+    end
+
+    return [ nil, nil ]
+  end
+end

data/lib/finmodeling/capm.rb

@@ -0,0 +1,80 @@
+module FinModeling
+
+  module CAPM
+    # References:
+    # 1. http://business.baylor.edu/don_cunningham/How_Firms_Estimate_Cost_of_Capital_(2011).pdf
+    #    "Current Trends in Estimating and Applying the Cost of Capital" (2011)
+    # 2. http://pages.stern.nyu.edu/~adamodar/pdfiles/valn2ed/ch8.pdf
+    #    "Estimating Risk Parameters and Costs of Financing"
+    # 3. http://www.cb.wsu.edu/~nwalcott/finance425/Readings/BRUNEREst_Cost_of_Capital.pdf
+    #    "Best Practices in Estimating the Cost of Capital: Survey and Synthesis" (1998)
+    # 4. http://www.nek.lu.se/NEKAVI/Cost%20of%20Capital%20slides.pdf
+    #    "Estimating Cost of Capital" (2009)
+
+    MARKET_PREMIUM = 0.055 # FIXME: this is totally arbitrary. Find a better way to represent the fact that this is a probability distribution
+
+    class RiskFreeRate
+      # Possible symbols:
+      # "^TNX"  -> CBOEInterestRate10-YearT-Note (Good for long-term, future-oriented decisions)
+      # ?       -> 90-day t-bill                 (Good for historical short-period R_f estimation)
+      def self.forward_estimate(risk_free_symbol="^TNX")
+        quotes = YahooFinance::get_HistoricalQuotes_days(URI::encode(risk_free_symbol), num_days=1)
+        FinModeling::Rate.new(quotes.last.adjClose / 100.0)
+      end
+    end
+
+    class Beta
+      # Possible index tickers:
+      # "Spy"   -> S&P 500
+      # "^IXIC" -> Nasdaq
+      def self.from_ticker(company_ticker, num_days=6*365, index_ticker="SPY")
+        index_quotes   = FamaFrench::EquityHistoricalData.new(index_ticker,   num_days)
+        company_quotes = FamaFrench::EquityHistoricalData.new(company_ticker, num_days)
+ 
+        common_dates = index_quotes  .year_and_month_strings &
+                       company_quotes.year_and_month_strings
+
+        index_quotes  .filter_by_date!(common_dates)
+        company_quotes.filter_by_date!(common_dates)
+  
+        index_div_hist   = NasdaqQuery::DividendHistory.for_symbol(index_ticker)
+        company_div_hist = NasdaqQuery::DividendHistory.for_symbol(company_ticker)
+   
+        index_monthly_returns   = index_quotes  .monthly_returns(index_div_hist)
+        company_monthly_returns = company_quotes.monthly_returns(company_div_hist)
+  
+        x = GSL::Vector.alloc(index_monthly_returns)
+        y = GSL::Vector.alloc(company_monthly_returns)
+        intercept, slope, cov00, cov01, cov11, chisq, status = GSL::Fit::linear(x, y)
+  
+        # FIXME: evaluate [intercept - Rf*(1-beta)]. It tells how much better/worse than expected (given its risk) the stock did. [per time period]
+
+        # FIXME: subtracting/adding one standard error of the beta gives a 95% confidence interval. That could be used to give a confidence interval
+        #        for the resulting valuation.
+
+        beta = slope
+      end
+    end
+
+    class AdjustedBeta # see: http://financetrain.com/adjusted-and-unadjusted-beta/
+      MEAN_LONG_TERM_BETA = 1.0
+      def self.from_beta(raw_beta)
+        ((2.0*raw_beta) + (1.0*MEAN_LONG_TERM_BETA)) / 3.0
+      end
+    end
+
+    class EquityCostOfCapital
+      def self.from_beta(beta)
+        Rate.new(RiskFreeRate.forward_estimate.value + (beta * MARKET_PREMIUM))
+      end
+
+      def self.from_ticker(company_ticker)
+        raw_beta = Beta.from_ticker(company_ticker)
+        puts "CAPM::EquityCostOfCapital -> raw beta = #{raw_beta}"
+        adj_beta = AdjustedBeta.from_beta(raw_beta)
+        puts "CAPM::EquityCostOfCapital -> adj beta = #{adj_beta}"
+        self.from_beta(adj_beta)
+      end
+    end
+  end
+end