rebalance 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+spec/spec.watchr
+tags

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rebalance.gemspec
+gemspec

data/README.md

@@ -0,0 +1,100 @@
+Rebalance
+====
+
+I don't fancy myself a savvy investor.  Instead, I like to stick to basic rules
+and let the magic of time and markets slowly grow my investments.  One way to do
+this is investing in passive index funds and sticking to a pre-defined asset allocation.
+Then, it's just a matter of rebalancing every once in a while to make sure the
+allocations are in line with the goal. Sounds pretty simple, right?
+
+Well, it gets slightly more complex you have multiple accounts with multiple funds
+in each.  Trying to figure out the best way rebalance across all of these accounts
+can be frustrating and eventually led me to write this gem.  You feed it all of your
+investment information (one account or many) and it will tell you exactly what to
+buy and sell in order to bring your asset allocation back into line.
+
+## Install ####################################################################
+
+    $ gem install rebalance
+
+## Usage ######################################################################
+
+Here's a basic example of a script using rebalance:
+
+    require 'rubygems'
+    require 'rebalance'
+
+    target = Rebalance::Target.new do
+      asset_class 35, 'US Total Market'
+      asset_class 18, 'Pacific'
+      asset_class 18, 'Europe'
+      asset_class 8,  'Real Estate'
+      asset_class 8,  'Total Bond Market'
+      asset_class 8,  'Inflation-Protected Bonds'
+      asset_class 5,  'US Small Cap Value'
+    end
+
+    wifes_roth = Rebalance::Account.new "Wife's Roth" do
+      fund 'VIPSX', 'Inflation-Protected Bonds', 200, 14.36
+      fund 'VBMFX', 'Total Bond Market', 500, 11.03
+    end
+
+    my_roth = Rebalance::Account.new 'My Roth' do
+      fund 'VISVX', 'US Small Cap Value', 200, 13.96
+      fund 'VGSIX', 'Real Estate', 100, 17.30
+      fund 'VTSAX', 'US Total Market', 300, 29.02
+      fund 'VPACX', 'Pacific', 300, 8.96
+      fund 'VEURX', 'Europe', 50, 21.46
+    end
+
+    my_traditional_ira = Rebalance::Account.new 'My Traditional IRA' do
+      fund 'VTSAX', 'US Total Market', 500, 29.02
+      fund 'VMMXX', 'Cash', 2500, 1.00
+    end
+
+    accounts_to_rebalance = Rebalance::Rebalancer.new(target, wifes_roth, my_roth, my_traditional_ira)
+    accounts_to_rebalance.rebalance
+    accounts_to_rebalance.print_results
+
+This will output:
+
+    +--------------------------------------------------------------------------------------------------+
+    |      Account       | Fund  |        Asset Class        | Price  | Amount To Buy | Amount To Sell |
+    +--------------------------------------------------------------------------------------------------+
+    | Wife's Roth        | VIPSX | Inflation-Protected Bonds | $14.36 | $461.05       | $0.00          |
+    | Wife's Roth        | VBMFX | Total Bond Market         | $11.03 | $0.00         | $4,044.40      |
+    | Wife's Roth        | VEURX | Europe                    | $21.46 | $3,583.35     | $0.00          |
+    | My Roth            | VISVX | US Small Cap Value        | $13.96 | $0.00         | $646.31        |
+    | My Roth            | VGSIX | Real Estate               | $17.30 | $1,699.74     | $0.00          |
+    | My Roth            | VTSAX | US Total Market           | $29.02 | $0.00         | $10,880.91     |
+    | My Roth            | VPACX | Pacific                   | $8.96  | $4,962.98     | $0.00          |
+    | My Roth            | VEURX | Europe                    | $21.46 | $2,973.13     | $0.00          |
+    | My Roth            | VBMFX | Total Bond Market         | $11.03 | $1,891.37     | $0.00          |
+    | My Traditional IRA | VTSAX | US Total Market           | $29.02 | $2,500.01     | $0.00          |
+    | My Traditional IRA | VMMXX | Cash                      | $1.00  | $0.00         | $2,500.00      |
+    +--------------------------------------------------------------------------------------------------+
+
+## License ###################################################################
+
+(The MIT License)
+
+Copyright (c) 2011 Bryce Thornton
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/rebalance/*_spec.rb']
+  t.verbose = true
+end

data/lib/rebalance.rb

@@ -0,0 +1,4 @@
+require 'rebalance/target'
+require 'rebalance/account'
+require 'rebalance/fund'
+require 'rebalance/rebalancer'

data/lib/rebalance/account.rb

@@ -0,0 +1,42 @@
+module Rebalance
+  class Account
+    attr_accessor :name, :funds, :rebalanced_funds
+
+    def initialize(name, &block)
+      self.name = name
+      self.funds = {}
+      self.rebalanced_funds = {}
+
+      instance_eval &block
+    end
+
+    def fund(symbol, asset_class, shares, price=nil)
+      new_fund = Fund.new(symbol, asset_class, shares, price)
+      self.funds[new_fund.symbol] = new_fund
+    end
+
+    def total_value
+      total_value = 0
+      funds.each do |symbol, fund|
+        total_value = total_value + fund.value
+      end
+      total_value
+    end
+
+    def calculate_percentages
+      percentages = {}
+      funds.each do |symbol, fund|
+        percentages[fund.symbol] = (fund.value / total_value * 100).round(2)
+      end
+      percentages
+    end
+
+    def find_by_asset_class(asset_class)
+      asset_class_funds = []
+      funds.each do |symbol, fund|
+        asset_class_funds << fund if fund.asset_class == asset_class
+      end
+      asset_class_funds
+    end
+  end
+end

data/lib/rebalance/fund.rb

@@ -0,0 +1,45 @@
+require 'open-uri'
+require 'json'
+
+module Rebalance
+  class Fund
+    attr_accessor :symbol, :name, :asset_class, :shares, :price
+
+    def initialize(symbol, asset_class, shares, price=nil)
+      self.symbol      = symbol
+      self.asset_class = asset_class
+      self.shares      = shares
+
+      # Lookup value if not passed in
+      if price.nil?
+        price = get_fund_price(symbol)
+      end
+
+      self.price = price
+    end
+
+    def get_fund_price(symbol)
+      yql_url = "http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20yahoo.finance.quotes%20where%20symbol%20in%20(%22#{symbol}%22)&env=store://datatables.org/alltableswithkeys&format=json"
+      response = open(yql_url)
+      parsed_response = JSON.parse(response.read)
+
+      if !parsed_response['query']['results']['quote']['ErrorIndicationreturnedforsymbolchangedinvalid'].nil?
+        raise "The symbol #{symbol} can't be found"
+      end
+
+      price = parsed_response['query']['results']['quote']['LastTradePriceOnly']
+      price = price.to_f
+
+      # Cash funds don't always return a price, so just assume $1.00
+      if asset_class == "Cash"
+        price = 1.00
+      end
+
+      price
+    end
+
+    def value
+      (price * shares).round(2)
+    end
+  end
+end

data/lib/rebalance/rebalancer.rb

@@ -0,0 +1,306 @@
+require 'ruport'
+
+module Rebalance
+  class Rebalancer
+    attr_accessor :accounts,
+      :target,
+      :acceptable_asset_class_delta,
+      :rebalanced_shares,
+      :rebalanced_values,
+      :rebalanced_share_difference,
+      :rebalanced_value_difference
+
+    def initialize(target, *accounts)
+      @target = target
+      # make sure we add empty funds where appropriate before we start rebalancing
+      # in order to allow all accounts/funds to balance properly
+      @accounts = accounts
+
+      @acceptable_asset_class_delta = 1.0
+
+      initialize_result_values
+    end
+
+    def initialize_result_values
+      @rebalanced_shares = {}
+      @rebalanced_values = {}
+      @rebalanced_share_difference = {}
+      @rebalanced_value_difference = {}
+
+      if @accounts.size > 1
+        @accounts.each do |account|
+          @rebalanced_shares[account.name] = {}
+          @rebalanced_values[account.name] = {}
+          @rebalanced_share_difference[account.name] = {}
+          @rebalanced_value_difference[account.name] = {}
+        end
+      end
+    end
+
+    def rebalance
+      initialize_result_values
+
+      if @accounts.size == 1
+        single_account_rebalance
+      elsif @accounts.size > 1
+        multiple_account_rebalance
+      end
+    end
+
+    def calculate_rebalanced_asset_class_values
+      # First, create a hash of symbols and their asset classes
+      symbol_asset_class_hash = {}
+      @accounts.each do |account|
+        account.funds.each do |symbol, fund|
+          symbol_asset_class_hash[symbol] = fund.asset_class
+        end
+      end
+
+      values = {}
+      if @accounts.size > 1
+        @rebalanced_values.each do |account, symbol_value_hash|
+          symbol_value_hash.each do |symbol, value|
+            asset_class = symbol_asset_class_hash[symbol]
+            values[asset_class] = 0 if values[asset_class].nil?
+            values[asset_class] += value
+          end
+        end
+      else
+        @rebalanced_values.each do |symbol, value|
+          asset_class = symbol_asset_class_hash[symbol]
+          values[asset_class] = 0 if values[asset_class].nil?
+          values[asset_class] += value
+        end
+      end
+      values
+    end
+
+    def funds_by_asset_class
+      asset_class_hash = {}
+      @accounts.each do |account|
+        account.funds.each do |symbol, fund|
+          asset_class_hash[fund.asset_class] = [] if asset_class_hash[fund.asset_class].nil?
+          asset_class_hash[fund.asset_class] << fund if !asset_class_hash[fund.asset_class].include?(fund)
+        end
+      end
+      asset_class_hash
+    end
+
+    # Print a pretty table of our results
+    def results
+      data = Table('Account','Fund','Asset Class', 'Price','Amount To Buy','Amount To Sell')
+
+      @rebalanced_value_difference.each do |account, funds|
+        funds.each do |symbol, val_diff|
+          price = fund_hash[symbol].price
+          asset_class = fund_hash[symbol].asset_class
+          amount_to_buy = 0
+          amount_to_buy = val_diff.abs if val_diff > 0
+          amount_to_sell = 0
+          amount_to_sell = val_diff.abs if val_diff < 0
+
+          data_array = [account, symbol, asset_class, format_currency(price), format_currency(amount_to_buy), format_currency(amount_to_sell)]
+          data << data_array
+        end
+      end
+
+      data
+    end
+
+    def print_results
+      p results
+    end
+
+    private
+    def single_account_rebalance
+      account = @accounts.first
+      target_asset_class_values = @target.calculate_target_asset_class_values(account)
+
+      target_asset_class_values.each do |asset_class, target_value|
+        rebalanced_asset_class = rebalance_asset_class_within_account(account, asset_class, target_value)
+
+        @rebalanced_shares.merge!(rebalanced_asset_class['rebalanced_shares'])
+        @rebalanced_share_difference.merge!(rebalanced_asset_class['rebalanced_share_difference'])
+        @rebalanced_values.merge!(rebalanced_asset_class['rebalanced_values'])
+        @rebalanced_value_difference.merge!(rebalanced_asset_class['rebalanced_value_difference'])
+      end
+    end
+
+    def multiple_account_rebalance
+      # Rebalance accounts by asset class percentage
+      account_percentages = rebalance_account_percentages
+
+      # Try to rebalance up to 10 times
+      i = 0
+      while i < 10 && unbalanced_asset_classes = find_unbalanced_asset_classes(account_percentages)
+        i += 1
+        @accounts = add_empty_funds(unbalanced_asset_classes)
+        account_percentages = rebalance_account_percentages
+      end
+
+      total_value = @target.total_value_of_all_accounts(*@accounts)
+
+      # Now, turn those asset class percentages back into balanced funds
+      @accounts.each do |account|
+        target_asset_class_percentages = account_percentages[account.name]
+
+        # Convert the percentages into values
+        target_asset_class_values = {}
+        target_asset_class_percentages.each do |asset_class, percentage|
+          target_value = total_value * (percentage * 0.01)
+          target_asset_class_values[asset_class] = target_value
+        end
+
+        target_asset_class_values.each do |asset_class, target_value|
+          rebalanced_asset_class = rebalance_asset_class_within_account(account, asset_class, target_value)
+
+          @rebalanced_shares[account.name].merge!(rebalanced_asset_class['rebalanced_shares'])
+          @rebalanced_share_difference[account.name].merge!(rebalanced_asset_class['rebalanced_share_difference'])
+          @rebalanced_values[account.name].merge!(rebalanced_asset_class['rebalanced_values'])
+          @rebalanced_value_difference[account.name].merge!(rebalanced_asset_class['rebalanced_value_difference'])
+        end
+      end
+    end
+
+    def find_unbalanced_asset_classes(account_percentages)
+      target_percentages = target.calculate_target_asset_class_percentages(*@accounts)
+
+      rebalanced_asset_classes = {}
+
+      account_percentages.each do |account_name, asset_class_hash|
+        asset_class_hash.each do |asset_class, rebalanced_percentage|
+          rebalanced_asset_classes[asset_class] = 0 if rebalanced_asset_classes[asset_class].nil?
+          rebalanced_asset_classes[asset_class] += rebalanced_percentage
+        end
+      end
+
+      unbalanced_asset_classes = []
+
+      rebalanced_asset_classes.each do |asset_class, rebalanced_asset_class_percentage|
+        if !target_percentages[asset_class].nil?
+          if (rebalanced_asset_class_percentage - target_percentages[asset_class]).abs > @acceptable_asset_class_delta
+            unbalanced_asset_classes << asset_class
+          end
+        end
+      end
+
+      if !unbalanced_asset_classes.empty?
+        unbalanced_asset_classes
+      else
+        false
+      end
+    end
+
+    def add_empty_funds(unbalanced_asset_classes)
+      # Loop through each account and add an empty fund from
+      # a missing asset class to an account that doesn't currently
+      # carry it.
+      temp_accounts = []
+      added_asset_classes = []
+      @accounts.each do |account|
+        unbalanced_asset_classes.each do |unbalanced_asset_class|
+          # If we can't find this asset class in this account
+          # then add it
+          if account.find_by_asset_class(unbalanced_asset_class).empty? && !added_asset_classes.include?(unbalanced_asset_class)
+            asset_class_funds = funds_by_asset_class
+            fund_to_add = asset_class_funds[unbalanced_asset_class].first
+            added_asset_classes << unbalanced_asset_class
+            account.fund(fund_to_add.symbol, unbalanced_asset_class, 0, fund_to_add.price)
+          end
+        end
+        temp_accounts << account
+      end
+
+      temp_accounts
+    end
+
+    # Helper that simply pulls the funds out of each account into a hash
+    def fund_hash
+      funds = {}
+      @accounts.each do |account|
+        funds.merge!(account.funds)
+      end
+      funds
+    end
+
+    def rebalance_asset_class_within_account(account, class_name, target_value)
+      return_values = {
+        'rebalanced_shares' => {},
+        'rebalanced_share_difference' => {},
+        'rebalanced_values' => {},
+        'rebalanced_value_difference' => {}
+      }
+
+      funds = account.find_by_asset_class(class_name)
+      per_fund_target_value = target_value / funds.size
+
+      funds.each do |fund|
+        amount_difference = (fund.value - per_fund_target_value)
+
+        new_shares = ((fund.value - amount_difference)/fund.price)
+        share_difference = (new_shares - fund.shares).round(2)
+
+        symbol = fund.symbol
+
+        return_values['rebalanced_shares'][symbol] = new_shares.round(4)
+        return_values['rebalanced_share_difference'][symbol] = share_difference
+        return_values['rebalanced_values'][symbol] = (new_shares * fund.price).round(2)
+        return_values['rebalanced_value_difference'][symbol] = (return_values['rebalanced_values'][symbol] - fund.value).round(2)
+      end
+
+      return_values
+    end
+
+    def rebalance_account_percentages
+      working_account_percentages = @target.asset_class_percentages_across_all_accounts(*@accounts)
+      working_asset_class_percentages = @target.calculate_current_asset_class_percentages(*@accounts)
+
+      100.times do |num|
+        working_account_percentages.each do |account_name, a_classes|
+          # We need to deal with single fund accounts seperately
+          if a_classes.size > 1
+            a_classes.each do |class_name, percentage|
+              target_value = @target.asset_classes[class_name] || 0
+              diff = target_value - working_asset_class_percentages[class_name]
+
+              # See if the target asset class % is greater than our overall asset class %
+              if diff
+                if diff > 0
+                  diff > 1 ? adjustment_size = 1 : adjustment_size = diff
+                else
+                  diff < -1 ? adjustment_size = -1 : adjustment_size = diff
+                end
+
+                if adjustment_size > 0.1 or adjustment_size < -0.1
+                  working_account_percentages[account_name][class_name] += adjustment_size
+                  working_asset_class_percentages[class_name] += adjustment_size
+
+                  # Now, go through the rest of the asset classes here and decrement
+                  # evenly to keep this account's overall percentage the same
+                  percent_to_change = adjustment_size.quo(a_classes.size-1).to_f * -1
+                  a_classes.each do |temp_class_name, temp_percentage|
+                    next if temp_class_name == class_name
+                    working_account_percentages[account_name][temp_class_name] += percent_to_change
+                    working_asset_class_percentages[temp_class_name] += percent_to_change
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      working_account_percentages
+    end
+
+    # takes a number and outputs a string in any currency format
+    # adapted from http://codesnippets.joyent.com/posts/show/1812
+    def format_currency(number)
+      # split integer and fractional parts
+      int, frac = ("%.2f" % number).split('.')
+      # insert the delimiters
+      int.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+      '$' + int + '.' + frac
+    end
+  end
+end