Recursive function for CPI

Having a play around trying to better understand recursion. I want to make a function that shows the CPI increase for a particular year given a starting amount.

Assuming the starting amount is 100000 and CPI rate is 5%, then f(0) = 100000, f(1) = 5000, f(2) = 5250 etc.I want to return the CPIincrease column from below

                               rate  0.05
n   TotalCPI    CPIincrease 
0   100000      
1   105000      5000    
2   110250      5250    
3   115762.5    5512.5  
4   121550.625  5788.125    
5   127628.1563 6077.53125  
6   134009.5641 6381.407812 
7   140710.0423 6700.478203 
8   147745.5444 7035.502113 
9   155132.8216 7387.277219 
10  162889.4627 7756.64108

So far I have the TotalCPI from column of the above table

def CPIincreases(n):
    if n<=0:
        return initial
    else:
        return (CPIincreases(n-1))*(1+CPIrate)

initial = 100000
CPIrate = 0.05

print(CPIincreases(1),CPIincreases(2),CPIincreases(3),CPIincreases(4))
output: 105000.0 110250.0 115762.5 121550.625

Now I'm lost. Because the output shows the I should be adding in

CPIincrease(n) - CPIincrease(n-1)

Somewhere.

Any Help greatly appreciated, even if its to say this function is not possible.

Cheers

Solution

The function you have created calculates the total value of the lump sum over time, and as you have pointed out, you can call it twice (once with year and once with year - 1) and take the difference to get your answer.

If you really want do this recursively in one go we need to think through the base cases:

Year 0: At the beginning there is no interest
- return 0
Year 1: After the first year the change is just the initial amount times the interest rate
- return initial * rate
Year 2+: From this year on, we make the same as last year, plus the interest on that interest
- return last_year + rate * last_year
- Or just: return last_year * (1 + rate)

Now we can put it all together:

def cpi_increase(year, initial, rate):
    if year == 0:
        return 0

    if year == 1:
        return initial * rate

    return (1 + rate) * cpi_increase(year - 1, initial, rate)

If we print this out we can see the values about match up:

initial = 100000
rate = 0.05

for year in range(11):
    print('{year:<5} {total:<21} {cpi_increase}'.format(
        year=year,
        total=initial * (1 + rate) ** year,
        cpi_increase=cpi_increase(year, initial, rate)
    ))

The values:

0     100000.0              0
1     105000.0              5000.0
2     110250.0              5250.0
3     115762.50000000001    5512.5
4     121550.62500000003    5788.125
5     127628.15625000003    6077.53125
6     134009.56406250005    6381.407812500001
7     140710.04226562506    6700.478203125001
8     147745.5443789063     7035.502113281251
9     155132.8215978516     7387.2772189453135
10    162889.4626777442     7756.64107989258

Thinking through our base cases also shows how to create the direct calculation. At year y we have applied the (1 + rate) multiplication y - 1 times and the base (initial * rate) once. This gives us:

def cpi_increase_direct(year, initial, rate):
    if year <= 0:
        return 0

    return initial * rate * (1 + rate) ** (year - 1)