Retirement Simulator #2: Apply an interest rate and verify it!

Published Dec. 31, 2021, 4:33 p.m.

In our last tutorial we set up the bare bones for our simulator.  We took the empirical approach where our simulator "looks like" what we might do already: we put money into an account and hope for the best.  Well this time we start to work on the "magic" portion of our simulator-- assigning interest rates!  Don't worrry!  Its way more boring than it sounds. Also math. 

Well don't get discouraged, all the math is done for you.  You don't have to understand it fully.  Follow along and at the end we will verify that our interest rate is the rate that we actually think it is.

When last we left off, our code looked something like this:

import sys, os
from datetime import date, timedelta

todays_date = date.today()

two_weeks = timedelta(days = 14)
one_year = timedelta(days = 365.25)
one_month = one_year/12
semi_monthly = one_month/2

pay_frequency = two_weeks

amount_already_in_retirement = 10000

paychecks_per_year = int(round(one_year/pay_frequency, 0))

Current_Salary = 50000
one_paycheck = Current_Salary/paychecks_per_year
add_to_retirement = 0.10*one_paycheck
# add_to_retirement = 100

retirement_date = date(2030, 3, 31)

retirement = amount_already_in_retirement

while todays_date < retirement_date:
    retirement += add_to_retirement
    todays_date += pay_frequency

print(f"I have {retirement:.2f} in my retirement as of {todays_date}.")    


### TEST: ###
retirement = 100
print("TEST")
for i in range(number_of_paychecks_per_year):
    retirement += 1
    print(f"I have {retirement:.2f} in my retirement after {i+1} paychecks.")

If your "TEST" portion is still active, "comment" it out using the "#" character.

So now we want our money to grow by some reasonable interest rate.  We don't exactly know what that would be yet. However, the approach I am going to take is to guess a number for the interest rate here at the beginning in order to get some of the math working properly.  Because if you have ever thought about it you might have heard about a market return of 5% or 10% or 20% but that doesen't mean that you add 20% to your account every two weeks.  Those rates are annual interest rates.  So if we had $100 in our account on January 1, and the "market rate" that year was 5%, and we didn't add any money to the account for the whole year, then on December 31 of the same year we would have $105 in the account. 

So our problem is that we do add money throughout the year and interest should be applied to that money but not the full market rate.  So how can we apply an incremental interest rate with the correct math?  The answer has to do with our pay frequency. 

As we have established the money in our account on January 1 should get the full market rate and everything else should get a smaller boost.  (In reality, the market fluxuates quite a bit and we could simulate that if we wanted to but it is more complicated with no payoff so we won't.) 

We are going to calculate what I call a "paycheck interest rate" given an "annual interest rate".  (At this point, take or leave the math-- just follow along and we will verify that it works like we expect at the end.)

If our annual interest rate (A) was 5% = (0.05)  then our hypothetical $100 on January 1 should end up as $105 by Dec. 31.

(Old Total)* (1 + A) =  Final Total

If we get paid 26 times per year, we should have a paycheck interest rate (PIR) that when applied 26 times gives the same total:

(Old Total)*(1+PIR) --> (Total2)

(Total2)*(1+PIR) --> (Total3)

(Total3)*(1+PIR) --> (Total4)

(Total4)*(1+PIR) --> (Total5)

...

(Total25)*(1+PIR) --> (Total26) = Final Total

The (1+PIR) factor is applied 26 times.  This means that the following is true:

(Old Total)*(1+PIR)^(26) --> Final Total

But that looks like our original equation (sort of):

(Old Total)*(1+PIR)^(26) = Final Total

(Old Total)* (1 + A)         =  Final Total

So that means (1+A) = (1+PIR)^26. Now at this point you might have to trust me.  But you take a few logarithms and do some rearanging and you find out that:

PIR= exp((1/26)*log(1+A)) - 1

Now the great thing about python and math is that you only care about the final result.  So our python function only needs to have the annual interest rate and the number of paychecks per year as input and it can output the "paycheck interest rate"  However, I think it is wise to add a comment about what we are doing and how we got there in our code for posterity.

"""
want to convert annual_interst_rate into a bi-weekly interest rate equivalent.

bwir should be such that (1+bwir)**26 =  air (annual_interst_rate)

26*log((1+bwir)) = log(1+air)

log((1+bwir)) = (1/26)*log(1+air)

1 + bwir = exp((1/26)*log(1+air))

bwir = exp((1/26)*log(1+air)) - 1

"""

def get_paycheck_interest_rate(annual_interst_rate, number_of_paychecks_per_year):
    return np.exp((1/number_of_paychecks_per_year)*np.log(1+annual_interst_rate)) - 1

You will notice that I use something called 'np.exp'.  That comes from the "numpy" module so to use it we need to go to top of our code and import it.

import numpy as np

This is the standard method to import this package.

So now, we can convert our annual interest rate into a paycheck interest rate and use it in our code!

if we haven't done so already, let's define an annual interest rate.

annual_interest_rate = 0.05

Then somewhere below our defined variables we should define our paycheck_interest_rate:

paycheck_interest_rate = get_paycheck_interest_rate(annual_interst_rate, paychecks_per_year)

And now we can use it in our loop:

while todays_date < retirement_date:
    retirement += add_to_retirement
    retirement *= (1+paycheck_interest_rate)
    todays_date += pay_frequency

The "*=" is of the same idea as the "+=" where we are shortening the expresssion:

retirement = retirement*(1+paycheck_interest_rate)

If it runs and we get no errors then we think that it is pretty good.  However, we would do well to verify our math here.

In fact, we can run a test very similar to our last one that will give us confidence in our model.

### TEST: ###
retirement = 100
print("TEST")
for i in range(paychecks_per_year):
    retirement *= (1+paycheck_interest_rate)
    print(np.round(retirement,2))

This test starts with 100 dollars and only multiplies by our "paycheck_interest_rate" over the number of paychecks per year. If our annual interest rate is 5% then we expect that at the end of the loop we will see 5 more dollars in the account (and in fact we do.)  Now we can change the interest rate and/or change the pay frequency and we should end up with the same result in our test.


Thanks for watching.  In the next one we will start to pick from a distribution of interest rates.

skip_nextRetirement Simulator #3: Use a Gaussian distribution of rates!
  • Retirement Simulator Introduction and Overview

  • Retirement Simulator #1: March through time with datetime and put money under the mattress!

  • Retirement Simulator #2: Apply an interest rate and verify it!
    (currently viewing)
  • Retirement Simulator #3: Use a Gaussian distribution of rates!

  • Retirement Simulator #3+: Verify our Gaussian distribution!

  • Retirement Simulator #4: Make a US market rates distribution

  • Retirement Simulator #5: Fit the Market Data with scipy curve_fit

  • Retirement Simulator #6: Sampling from our custom market distribution

  • Retirement Simulator #7: Organize multiple plots with subplots! and learn about plt.pause()

  • Retirement Simulator #8: Multiverse Investing: Simulate 1000 random investors

  • Retirement Simulator #9: Track averages and final outcomes

  • Retirement Simulator #10: Test and Compare Different Retirement dates (And make it pretty!)